Loading...
paper | - code | - explanation
ChatGPT PPT框架生成
""")
- with gr.Row():
- with gr.Column():
- openai_token = gr.Textbox(label="OpenAI API Key")
- topic = gr.Textbox(label="PPT的主题或内容")
- length = gr.Slider(minimum=1, maximum=20, value=6, label="生成的PPT页数", step=1)
- theme = gr.File(value="./theme.pptx", file_types=['pptx', 'ppt'], label="PPT模版")
- output_file = gr.File(interactive=False)
-
- topic.submit(
- fn=generate_ppt,
- inputs=[theme, topic, length, openai_token],
- outputs=[output_file]
- )
-
- submit = gr.Button("生成")
- submit.click(
- fn=generate_ppt,
- inputs=[theme, topic, length, openai_token],
- outputs=[output_file]
- )
-
-if __name__ == "__main__":
- demo.launch()
diff --git a/spaces/Alpaca233/SadTalker/src/face3d/models/arcface_torch/configs/glint360k_mbf.py b/spaces/Alpaca233/SadTalker/src/face3d/models/arcface_torch/configs/glint360k_mbf.py
deleted file mode 100644
index 46ae777cc97af41a531cba4e5d1ff31f2efcb468..0000000000000000000000000000000000000000
--- a/spaces/Alpaca233/SadTalker/src/face3d/models/arcface_torch/configs/glint360k_mbf.py
+++ /dev/null
@@ -1,26 +0,0 @@
-from easydict import EasyDict as edict
-
-# make training faster
-# our RAM is 256G
-# mount -t tmpfs -o size=140G tmpfs /train_tmp
-
-config = edict()
-config.loss = "cosface"
-config.network = "mbf"
-config.resume = False
-config.output = None
-config.embedding_size = 512
-config.sample_rate = 0.1
-config.fp16 = True
-config.momentum = 0.9
-config.weight_decay = 2e-4
-config.batch_size = 128
-config.lr = 0.1 # batch size is 512
-
-config.rec = "/train_tmp/glint360k"
-config.num_classes = 360232
-config.num_image = 17091657
-config.num_epoch = 20
-config.warmup_epoch = -1
-config.decay_epoch = [8, 12, 15, 18]
-config.val_targets = ["lfw", "cfp_fp", "agedb_30"]
diff --git a/spaces/Andy1621/uniformer_image_detection/configs/guided_anchoring/ga_retinanet_r101_caffe_fpn_mstrain_2x.py b/spaces/Andy1621/uniformer_image_detection/configs/guided_anchoring/ga_retinanet_r101_caffe_fpn_mstrain_2x.py
deleted file mode 100644
index 85fa2f5d73a896e09d7b1f72202d0a100eaca821..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/configs/guided_anchoring/ga_retinanet_r101_caffe_fpn_mstrain_2x.py
+++ /dev/null
@@ -1,167 +0,0 @@
-_base_ = '../_base_/default_runtime.py'
-
-# model settings
-model = dict(
- type='RetinaNet',
- pretrained='open-mmlab://detectron2/resnet101_caffe',
- backbone=dict(
- type='ResNet',
- depth=101,
- num_stages=4,
- out_indices=(0, 1, 2, 3),
- frozen_stages=1,
- norm_cfg=dict(type='BN', requires_grad=False),
- norm_eval=True,
- style='caffe'),
- neck=dict(
- type='FPN',
- in_channels=[256, 512, 1024, 2048],
- out_channels=256,
- start_level=1,
- add_extra_convs=True,
- num_outs=5),
- bbox_head=dict(
- type='GARetinaHead',
- num_classes=80,
- in_channels=256,
- stacked_convs=4,
- feat_channels=256,
- approx_anchor_generator=dict(
- type='AnchorGenerator',
- octave_base_scale=4,
- scales_per_octave=3,
- ratios=[0.5, 1.0, 2.0],
- strides=[8, 16, 32, 64, 128]),
- square_anchor_generator=dict(
- type='AnchorGenerator',
- ratios=[1.0],
- scales=[4],
- strides=[8, 16, 32, 64, 128]),
- anchor_coder=dict(
- type='DeltaXYWHBBoxCoder',
- target_means=[.0, .0, .0, .0],
- target_stds=[1.0, 1.0, 1.0, 1.0]),
- bbox_coder=dict(
- type='DeltaXYWHBBoxCoder',
- target_means=[.0, .0, .0, .0],
- target_stds=[1.0, 1.0, 1.0, 1.0]),
- loc_filter_thr=0.01,
- loss_loc=dict(
- type='FocalLoss',
- use_sigmoid=True,
- gamma=2.0,
- alpha=0.25,
- loss_weight=1.0),
- loss_shape=dict(type='BoundedIoULoss', beta=0.2, loss_weight=1.0),
- loss_cls=dict(
- type='FocalLoss',
- use_sigmoid=True,
- gamma=2.0,
- alpha=0.25,
- loss_weight=1.0),
- loss_bbox=dict(type='SmoothL1Loss', beta=0.04, loss_weight=1.0)))
-# training and testing settings
-train_cfg = dict(
- ga_assigner=dict(
- type='ApproxMaxIoUAssigner',
- pos_iou_thr=0.5,
- neg_iou_thr=0.4,
- min_pos_iou=0.4,
- ignore_iof_thr=-1),
- ga_sampler=dict(
- type='RandomSampler',
- num=256,
- pos_fraction=0.5,
- neg_pos_ub=-1,
- add_gt_as_proposals=False),
- assigner=dict(
- type='MaxIoUAssigner',
- pos_iou_thr=0.5,
- neg_iou_thr=0.5,
- min_pos_iou=0.0,
- ignore_iof_thr=-1),
- allowed_border=-1,
- pos_weight=-1,
- center_ratio=0.2,
- ignore_ratio=0.5,
- debug=False)
-test_cfg = dict(
- nms_pre=1000,
- min_bbox_size=0,
- score_thr=0.05,
- nms=dict(type='nms', iou_threshold=0.5),
- max_per_img=100)
-# dataset settings
-dataset_type = 'CocoDataset'
-data_root = 'data/coco/'
-img_norm_cfg = dict(
- mean=[103.530, 116.280, 123.675], std=[1.0, 1.0, 1.0], to_rgb=False)
-train_pipeline = [
- dict(type='LoadImageFromFile'),
- dict(type='LoadAnnotations', with_bbox=True),
- dict(
- type='Resize',
- img_scale=[(1333, 480), (1333, 960)],
- keep_ratio=True,
- multiscale_mode='range'),
- dict(type='RandomFlip', flip_ratio=0.5),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='Pad', size_divisor=32),
- dict(type='DefaultFormatBundle'),
- dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']),
-]
-test_pipeline = [
- dict(type='LoadImageFromFile'),
- dict(
- type='MultiScaleFlipAug',
- img_scale=(1333, 800),
- flip=False,
- transforms=[
- dict(type='Resize', keep_ratio=True),
- dict(type='RandomFlip'),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='Pad', size_divisor=32),
- dict(type='ImageToTensor', keys=['img']),
- dict(type='Collect', keys=['img']),
- ])
-]
-data = dict(
- samples_per_gpu=2,
- workers_per_gpu=2,
- train=dict(
- type=dataset_type,
- ann_file=data_root + 'annotations/instances_train2017.json',
- img_prefix=data_root + 'train2017/',
- pipeline=train_pipeline),
- val=dict(
- type=dataset_type,
- ann_file=data_root + 'annotations/instances_val2017.json',
- img_prefix=data_root + 'val2017/',
- pipeline=test_pipeline),
- test=dict(
- type=dataset_type,
- ann_file=data_root + 'annotations/instances_val2017.json',
- img_prefix=data_root + 'val2017/',
- pipeline=test_pipeline))
-evaluation = dict(interval=1, metric='bbox')
-# optimizer
-optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
-optimizer_config = dict(grad_clip=dict(max_norm=35, norm_type=2))
-# learning policy
-lr_config = dict(
- policy='step',
- warmup='linear',
- warmup_iters=500,
- warmup_ratio=1.0 / 3,
- step=[16, 22])
-checkpoint_config = dict(interval=1)
-# yapf:disable
-log_config = dict(
- interval=50,
- hooks=[
- dict(type='TextLoggerHook'),
- # dict(type='TensorboardLoggerHook')
- ])
-# yapf:enable
-# runtime settings
-runner = dict(type='EpochBasedRunner', max_epochs=24)
diff --git a/spaces/Andy1621/uniformer_image_segmentation/configs/_base_/models/deeplabv3_r50-d8.py b/spaces/Andy1621/uniformer_image_segmentation/configs/_base_/models/deeplabv3_r50-d8.py
deleted file mode 100644
index d7a43bee01422ad4795dd27874e0cd4bb6cbfecf..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_segmentation/configs/_base_/models/deeplabv3_r50-d8.py
+++ /dev/null
@@ -1,44 +0,0 @@
-# model settings
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
- type='EncoderDecoder',
- pretrained='open-mmlab://resnet50_v1c',
- backbone=dict(
- type='ResNetV1c',
- depth=50,
- num_stages=4,
- out_indices=(0, 1, 2, 3),
- dilations=(1, 1, 2, 4),
- strides=(1, 2, 1, 1),
- norm_cfg=norm_cfg,
- norm_eval=False,
- style='pytorch',
- contract_dilation=True),
- decode_head=dict(
- type='ASPPHead',
- in_channels=2048,
- in_index=3,
- channels=512,
- dilations=(1, 12, 24, 36),
- dropout_ratio=0.1,
- num_classes=19,
- norm_cfg=norm_cfg,
- align_corners=False,
- loss_decode=dict(
- type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
- auxiliary_head=dict(
- type='FCNHead',
- in_channels=1024,
- in_index=2,
- channels=256,
- num_convs=1,
- concat_input=False,
- dropout_ratio=0.1,
- num_classes=19,
- norm_cfg=norm_cfg,
- align_corners=False,
- loss_decode=dict(
- type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
- # model training and testing settings
- train_cfg=dict(),
- test_cfg=dict(mode='whole'))
diff --git a/spaces/Andy1621/uniformer_image_segmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_512x512_20k_voc12aug.py b/spaces/Andy1621/uniformer_image_segmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_512x512_20k_voc12aug.py
deleted file mode 100644
index 1056ad4d1e2a4f956d12f6daf506620fab27dd17..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_segmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_512x512_20k_voc12aug.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
- '../_base_/models/deeplabv3plus_r50-d8.py',
- '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
- '../_base_/schedules/schedule_20k.py'
-]
-model = dict(
- decode_head=dict(num_classes=21), auxiliary_head=dict(num_classes=21))
diff --git a/spaces/Andy1621/uniformer_image_segmentation/configs/fp16/deeplabv3plus_r101-d8_512x1024_80k_fp16_cityscapes.py b/spaces/Andy1621/uniformer_image_segmentation/configs/fp16/deeplabv3plus_r101-d8_512x1024_80k_fp16_cityscapes.py
deleted file mode 100644
index eaf569d4d76af2e498c039899c01f9960b1158d9..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_segmentation/configs/fp16/deeplabv3plus_r101-d8_512x1024_80k_fp16_cityscapes.py
+++ /dev/null
@@ -1,5 +0,0 @@
-_base_ = '../deeplabv3plus/deeplabv3plus_r101-d8_512x1024_80k_cityscapes.py'
-# fp16 settings
-optimizer_config = dict(type='Fp16OptimizerHook', loss_scale=512.)
-# fp16 placeholder
-fp16 = dict()
diff --git a/spaces/Apex-X/GODROOP/roop/processors/__init__.py b/spaces/Apex-X/GODROOP/roop/processors/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/Apex-X/ROOPOK/roop/metadata.py b/spaces/Apex-X/ROOPOK/roop/metadata.py
deleted file mode 100644
index aea9e16d897ede57f566ccc773d0d2ee17905dfb..0000000000000000000000000000000000000000
--- a/spaces/Apex-X/ROOPOK/roop/metadata.py
+++ /dev/null
@@ -1,2 +0,0 @@
-name = 'roop'
-version = '1.3.2'
diff --git a/spaces/ArcanAlt/arcanDream/README.md b/spaces/ArcanAlt/arcanDream/README.md
deleted file mode 100644
index d82ee8d9d75a65ba4810f04d0f9cf2c771b44f36..0000000000000000000000000000000000000000
--- a/spaces/ArcanAlt/arcanDream/README.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: ArcanDream
-emoji: 💻
-colorFrom: green
-colorTo: green
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/tenacity/nap.py b/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/tenacity/nap.py
deleted file mode 100644
index 72aa5bfd4b60d8e6ef6ed0cf2ae4f763d12195cc..0000000000000000000000000000000000000000
--- a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/tenacity/nap.py
+++ /dev/null
@@ -1,43 +0,0 @@
-# Copyright 2016 Étienne Bersac
-# Copyright 2016 Julien Danjou
-# Copyright 2016 Joshua Harlow
-# Copyright 2013-2014 Ray Holder
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import time
-import typing
-
-if typing.TYPE_CHECKING:
- import threading
-
-
-def sleep(seconds: float) -> None:
- """
- Sleep strategy that delays execution for a given number of seconds.
-
- This is the default strategy, and may be mocked out for unit testing.
- """
- time.sleep(seconds)
-
-
-class sleep_using_event:
- """Sleep strategy that waits on an event to be set."""
-
- def __init__(self, event: "threading.Event") -> None:
- self.event = event
-
- def __call__(self, timeout: typing.Optional[float]) -> None:
- # NOTE(harlowja): this may *not* actually wait for timeout
- # seconds if the event is set (ie this may eject out early).
- self.event.wait(timeout=timeout)
diff --git a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pkg_resources/_vendor/more_itertools/__init__.py b/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pkg_resources/_vendor/more_itertools/__init__.py
deleted file mode 100644
index ea38bef1f661e62d577b3c2207386d901d851c72..0000000000000000000000000000000000000000
--- a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pkg_resources/_vendor/more_itertools/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from .more import * # noqa
-from .recipes import * # noqa
-
-__version__ = '8.12.0'
diff --git a/spaces/Audio-AGI/AudioSep/utils.py b/spaces/Audio-AGI/AudioSep/utils.py
deleted file mode 100644
index abfb28500aa2c7f7cf395a869245d4c2061f9ca5..0000000000000000000000000000000000000000
--- a/spaces/Audio-AGI/AudioSep/utils.py
+++ /dev/null
@@ -1,384 +0,0 @@
-import os
-import datetime
-import json
-import logging
-import librosa
-import pickle
-from typing import Dict
-import numpy as np
-import torch
-import torch.nn as nn
-import yaml
-from models.audiosep import AudioSep, get_model_class
-
-
-def ignore_warnings():
- import warnings
- # Ignore UserWarning from torch.meshgrid
- warnings.filterwarnings('ignore', category=UserWarning, module='torch.functional')
-
- # Refined regex pattern to capture variations in the warning message
- pattern = r"Some weights of the model checkpoint at roberta-base were not used when initializing RobertaModel: \['lm_head\..*'\].*"
- warnings.filterwarnings('ignore', message=pattern)
-
-
-
-def create_logging(log_dir, filemode):
- os.makedirs(log_dir, exist_ok=True)
- i1 = 0
-
- while os.path.isfile(os.path.join(log_dir, "{:04d}.log".format(i1))):
- i1 += 1
-
- log_path = os.path.join(log_dir, "{:04d}.log".format(i1))
- logging.basicConfig(
- level=logging.DEBUG,
- format="%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s",
- datefmt="%a, %d %b %Y %H:%M:%S",
- filename=log_path,
- filemode=filemode,
- )
-
- # Print to console
- console = logging.StreamHandler()
- console.setLevel(logging.INFO)
- formatter = logging.Formatter("%(name)-12s: %(levelname)-8s %(message)s")
- console.setFormatter(formatter)
- logging.getLogger("").addHandler(console)
-
- return logging
-
-
-def float32_to_int16(x: float) -> int:
- x = np.clip(x, a_min=-1, a_max=1)
- return (x * 32767.0).astype(np.int16)
-
-
-def int16_to_float32(x: int) -> float:
- return (x / 32767.0).astype(np.float32)
-
-
-def parse_yaml(config_yaml: str) -> Dict:
- r"""Parse yaml file.
-
- Args:
- config_yaml (str): config yaml path
-
- Returns:
- yaml_dict (Dict): parsed yaml file
- """
-
- with open(config_yaml, "r") as fr:
- return yaml.load(fr, Loader=yaml.FullLoader)
-
-
-def get_audioset632_id_to_lb(ontology_path: str) -> Dict:
- r"""Get AudioSet 632 classes ID to label mapping."""
-
- audioset632_id_to_lb = {}
-
- with open(ontology_path) as f:
- data_list = json.load(f)
-
- for e in data_list:
- audioset632_id_to_lb[e["id"]] = e["name"]
-
- return audioset632_id_to_lb
-
-
-def load_pretrained_panns(
- model_type: str,
- checkpoint_path: str,
- freeze: bool
-) -> nn.Module:
- r"""Load pretrained pretrained audio neural networks (PANNs).
-
- Args:
- model_type: str, e.g., "Cnn14"
- checkpoint_path, str, e.g., "Cnn14_mAP=0.431.pth"
- freeze: bool
-
- Returns:
- model: nn.Module
- """
-
- if model_type == "Cnn14":
- Model = Cnn14
-
- elif model_type == "Cnn14_DecisionLevelMax":
- Model = Cnn14_DecisionLevelMax
-
- else:
- raise NotImplementedError
-
- model = Model(sample_rate=32000, window_size=1024, hop_size=320,
- mel_bins=64, fmin=50, fmax=14000, classes_num=527)
-
- if checkpoint_path:
- checkpoint = torch.load(checkpoint_path, map_location="cpu")
- model.load_state_dict(checkpoint["model"])
-
- if freeze:
- for param in model.parameters():
- param.requires_grad = False
-
- return model
-
-
-def energy(x):
- return torch.mean(x ** 2)
-
-
-def magnitude_to_db(x):
- eps = 1e-10
- return 20. * np.log10(max(x, eps))
-
-
-def db_to_magnitude(x):
- return 10. ** (x / 20)
-
-
-def ids_to_hots(ids, classes_num, device):
- hots = torch.zeros(classes_num).to(device)
- for id in ids:
- hots[id] = 1
- return hots
-
-
-def calculate_sdr(
- ref: np.ndarray,
- est: np.ndarray,
- eps=1e-10
-) -> float:
- r"""Calculate SDR between reference and estimation.
-
- Args:
- ref (np.ndarray), reference signal
- est (np.ndarray), estimated signal
- """
- reference = ref
- noise = est - reference
-
-
- numerator = np.clip(a=np.mean(reference ** 2), a_min=eps, a_max=None)
-
- denominator = np.clip(a=np.mean(noise ** 2), a_min=eps, a_max=None)
-
- sdr = 10. * np.log10(numerator / denominator)
-
- return sdr
-
-
-def calculate_sisdr(ref, est):
- r"""Calculate SDR between reference and estimation.
-
- Args:
- ref (np.ndarray), reference signal
- est (np.ndarray), estimated signal
- """
-
- eps = np.finfo(ref.dtype).eps
-
- reference = ref.copy()
- estimate = est.copy()
-
- reference = reference.reshape(reference.size, 1)
- estimate = estimate.reshape(estimate.size, 1)
-
- Rss = np.dot(reference.T, reference)
- # get the scaling factor for clean sources
- a = (eps + np.dot(reference.T, estimate)) / (Rss + eps)
-
- e_true = a * reference
- e_res = estimate - e_true
-
- Sss = (e_true**2).sum()
- Snn = (e_res**2).sum()
-
- sisdr = 10 * np.log10((eps+ Sss)/(eps + Snn))
-
- return sisdr
-
-
-class StatisticsContainer(object):
- def __init__(self, statistics_path):
- self.statistics_path = statistics_path
-
- self.backup_statistics_path = "{}_{}.pkl".format(
- os.path.splitext(self.statistics_path)[0],
- datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"),
- )
-
- self.statistics_dict = {"balanced_train": [], "test": []}
-
- def append(self, steps, statistics, split, flush=True):
- statistics["steps"] = steps
- self.statistics_dict[split].append(statistics)
-
- if flush:
- self.flush()
-
- def flush(self):
- pickle.dump(self.statistics_dict, open(self.statistics_path, "wb"))
- pickle.dump(self.statistics_dict, open(self.backup_statistics_path, "wb"))
- logging.info(" Dump statistics to {}".format(self.statistics_path))
- logging.info(" Dump statistics to {}".format(self.backup_statistics_path))
-
-
-def get_mean_sdr_from_dict(sdris_dict):
- mean_sdr = np.nanmean(list(sdris_dict.values()))
- return mean_sdr
-
-
-def remove_silence(audio: np.ndarray, sample_rate: int) -> np.ndarray:
- r"""Remove silent frames."""
- window_size = int(sample_rate * 0.1)
- threshold = 0.02
-
- frames = librosa.util.frame(x=audio, frame_length=window_size, hop_length=window_size).T
- # shape: (frames_num, window_size)
-
- new_frames = get_active_frames(frames, threshold)
- # shape: (new_frames_num, window_size)
-
- new_audio = new_frames.flatten()
- # shape: (new_audio_samples,)
-
- return new_audio
-
-
-def get_active_frames(frames: np.ndarray, threshold: float) -> np.ndarray:
- r"""Get active frames."""
-
- energy = np.max(np.abs(frames), axis=-1)
- # shape: (frames_num,)
-
- active_indexes = np.where(energy > threshold)[0]
- # shape: (new_frames_num,)
-
- new_frames = frames[active_indexes]
- # shape: (new_frames_num,)
-
- return new_frames
-
-
-def repeat_to_length(audio: np.ndarray, segment_samples: int) -> np.ndarray:
- r"""Repeat audio to length."""
-
- repeats_num = (segment_samples // audio.shape[-1]) + 1
- audio = np.tile(audio, repeats_num)[0 : segment_samples]
-
- return audio
-
-def calculate_segmentwise_sdr(ref, est, hop_samples, return_sdr_list=False):
- min_len = min(ref.shape[-1], est.shape[-1])
- pointer = 0
- sdrs = []
- while pointer + hop_samples < min_len:
- sdr = calculate_sdr(
- ref=ref[:, pointer : pointer + hop_samples],
- est=est[:, pointer : pointer + hop_samples],
- )
- sdrs.append(sdr)
- pointer += hop_samples
-
- sdr = np.nanmedian(sdrs)
-
- if return_sdr_list:
- return sdr, sdrs
- else:
- return sdr
-
-
-def loudness(data, input_loudness, target_loudness):
- """ Loudness normalize a signal.
-
- Normalize an input signal to a user loudness in dB LKFS.
-
- Params
- -------
- data : torch.Tensor
- Input multichannel audio data.
- input_loudness : float
- Loudness of the input in dB LUFS.
- target_loudness : float
- Target loudness of the output in dB LUFS.
-
- Returns
- -------
- output : torch.Tensor
- Loudness normalized output data.
- """
-
- # calculate the gain needed to scale to the desired loudness level
- delta_loudness = target_loudness - input_loudness
- gain = torch.pow(10.0, delta_loudness / 20.0)
-
- output = gain * data
-
- # check for potentially clipped samples
- # if torch.max(torch.abs(output)) >= 1.0:
- # warnings.warn("Possible clipped samples in output.")
-
- return output
-
-
-def load_ss_model(
- configs: Dict,
- checkpoint_path: str,
- query_encoder: nn.Module
-) -> nn.Module:
- r"""Load trained universal source separation model.
-
- Args:
- configs (Dict)
- checkpoint_path (str): path of the checkpoint to load
- device (str): e.g., "cpu" | "cuda"
-
- Returns:
- pl_model: pl.LightningModule
- """
-
- ss_model_type = configs["model"]["model_type"]
- input_channels = configs["model"]["input_channels"]
- output_channels = configs["model"]["output_channels"]
- condition_size = configs["model"]["condition_size"]
-
- # Initialize separation model
- SsModel = get_model_class(model_type=ss_model_type)
-
- ss_model = SsModel(
- input_channels=input_channels,
- output_channels=output_channels,
- condition_size=condition_size,
- )
-
- # Load PyTorch Lightning model
- pl_model = AudioSep.load_from_checkpoint(
- checkpoint_path=checkpoint_path,
- strict=False,
- ss_model=ss_model,
- waveform_mixer=None,
- query_encoder=query_encoder,
- loss_function=None,
- optimizer_type=None,
- learning_rate=None,
- lr_lambda_func=None,
- map_location=torch.device('cpu'),
- )
-
- return pl_model
-
-
-def parse_yaml(config_yaml: str) -> Dict:
- r"""Parse yaml file.
-
- Args:
- config_yaml (str): config yaml path
-
- Returns:
- yaml_dict (Dict): parsed yaml file
- """
-
- with open(config_yaml, "r") as fr:
- return yaml.load(fr, Loader=yaml.FullLoader)
\ No newline at end of file
diff --git a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/tests/test_model_zoo.py b/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/tests/test_model_zoo.py
deleted file mode 100644
index e3360a74864e0c00ed92ffbc8531c8d36e8be379..0000000000000000000000000000000000000000
--- a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/tests/test_model_zoo.py
+++ /dev/null
@@ -1,50 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import logging
-import unittest
-
-from detectron2 import model_zoo
-from detectron2.config import instantiate
-from detectron2.modeling import FPN, GeneralizedRCNN
-
-logger = logging.getLogger(__name__)
-
-
-class TestModelZoo(unittest.TestCase):
- def test_get_returns_model(self):
- model = model_zoo.get("Misc/scratch_mask_rcnn_R_50_FPN_3x_gn.yaml", trained=False)
- self.assertIsInstance(model, GeneralizedRCNN)
- self.assertIsInstance(model.backbone, FPN)
-
- def test_get_invalid_model(self):
- self.assertRaises(RuntimeError, model_zoo.get, "Invalid/config.yaml")
-
- def test_get_url(self):
- url = model_zoo.get_checkpoint_url("Misc/scratch_mask_rcnn_R_50_FPN_3x_gn.yaml")
- self.assertEqual(
- url,
- "https://dl.fbaipublicfiles.com/detectron2/Misc/scratch_mask_rcnn_R_50_FPN_3x_gn/138602908/model_final_01ca85.pkl", # noqa
- )
- url2 = model_zoo.get_checkpoint_url("Misc/scratch_mask_rcnn_R_50_FPN_3x_gn.py")
- self.assertEqual(url, url2)
-
- def _build_lazy_model(self, name):
- cfg = model_zoo.get_config("common/models/" + name)
- instantiate(cfg.model)
-
- def test_mask_rcnn_fpn(self):
- self._build_lazy_model("mask_rcnn_fpn.py")
-
- def test_mask_rcnn_c4(self):
- self._build_lazy_model("mask_rcnn_c4.py")
-
- def test_panoptic_fpn(self):
- self._build_lazy_model("panoptic_fpn.py")
-
- def test_schedule(self):
- cfg = model_zoo.get_config("common/coco_schedule.py")
- for _, v in cfg.items():
- instantiate(v)
-
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/spaces/Bart92/RVC_HF/infer_batch_rvc.py b/spaces/Bart92/RVC_HF/infer_batch_rvc.py
deleted file mode 100644
index 15c862a3d6bf815fa68003cc7054b694cae50c2a..0000000000000000000000000000000000000000
--- a/spaces/Bart92/RVC_HF/infer_batch_rvc.py
+++ /dev/null
@@ -1,215 +0,0 @@
-"""
-v1
-runtime\python.exe myinfer-v2-0528.py 0 "E:\codes\py39\RVC-beta\todo-songs" "E:\codes\py39\logs\mi-test\added_IVF677_Flat_nprobe_7.index" harvest "E:\codes\py39\RVC-beta\output" "E:\codes\py39\test-20230416b\weights\mi-test.pth" 0.66 cuda:0 True 3 0 1 0.33
-v2
-runtime\python.exe myinfer-v2-0528.py 0 "E:\codes\py39\RVC-beta\todo-songs" "E:\codes\py39\test-20230416b\logs\mi-test-v2\aadded_IVF677_Flat_nprobe_1_v2.index" harvest "E:\codes\py39\RVC-beta\output_v2" "E:\codes\py39\test-20230416b\weights\mi-test-v2.pth" 0.66 cuda:0 True 3 0 1 0.33
-"""
-import os, sys, pdb, torch
-
-now_dir = os.getcwd()
-sys.path.append(now_dir)
-import sys
-import torch
-import tqdm as tq
-from multiprocessing import cpu_count
-
-
-class Config:
- def __init__(self, device, is_half):
- self.device = device
- self.is_half = is_half
- self.n_cpu = 0
- self.gpu_name = None
- self.gpu_mem = None
- self.x_pad, self.x_query, self.x_center, self.x_max = self.device_config()
-
- def device_config(self) -> tuple:
- if torch.cuda.is_available():
- i_device = int(self.device.split(":")[-1])
- self.gpu_name = torch.cuda.get_device_name(i_device)
- if (
- ("16" in self.gpu_name and "V100" not in self.gpu_name.upper())
- or "P40" in self.gpu_name.upper()
- or "1060" in self.gpu_name
- or "1070" in self.gpu_name
- or "1080" in self.gpu_name
- ):
- print("16系/10系显卡和P40强制单精度")
- self.is_half = False
- for config_file in ["32k.json", "40k.json", "48k.json"]:
- with open(f"configs/{config_file}", "r") as f:
- strr = f.read().replace("true", "false")
- with open(f"configs/{config_file}", "w") as f:
- f.write(strr)
- with open("infer/modules/train/preprocess.py", "r") as f:
- strr = f.read().replace("3.7", "3.0")
- with open("infer/modules/train/preprocess.py", "w") as f:
- f.write(strr)
- else:
- self.gpu_name = None
- self.gpu_mem = int(
- torch.cuda.get_device_properties(i_device).total_memory
- / 1024
- / 1024
- / 1024
- + 0.4
- )
- if self.gpu_mem <= 4:
- with open("infer/modules/train/preprocess.py", "r") as f:
- strr = f.read().replace("3.7", "3.0")
- with open("infer/modules/train/preprocess.py", "w") as f:
- f.write(strr)
- elif torch.backends.mps.is_available():
- print("没有发现支持的N卡, 使用MPS进行推理")
- self.device = "mps"
- else:
- print("没有发现支持的N卡, 使用CPU进行推理")
- self.device = "cpu"
- self.is_half = True
-
- if self.n_cpu == 0:
- self.n_cpu = cpu_count()
-
- if self.is_half:
- # 6G显存配置
- x_pad = 3
- x_query = 10
- x_center = 60
- x_max = 65
- else:
- # 5G显存配置
- x_pad = 1
- x_query = 6
- x_center = 38
- x_max = 41
-
- if self.gpu_mem != None and self.gpu_mem <= 4:
- x_pad = 1
- x_query = 5
- x_center = 30
- x_max = 32
-
- return x_pad, x_query, x_center, x_max
-
-
-f0up_key = sys.argv[1]
-input_path = sys.argv[2]
-index_path = sys.argv[3]
-f0method = sys.argv[4] # harvest or pm
-opt_path = sys.argv[5]
-model_path = sys.argv[6]
-index_rate = float(sys.argv[7])
-device = sys.argv[8]
-is_half = sys.argv[9].lower() != "false"
-filter_radius = int(sys.argv[10])
-resample_sr = int(sys.argv[11])
-rms_mix_rate = float(sys.argv[12])
-protect = float(sys.argv[13])
-print(sys.argv)
-config = Config(device, is_half)
-now_dir = os.getcwd()
-sys.path.append(now_dir)
-from infer.modules.vc.modules import VC
-from lib.infer_pack.models import (
- SynthesizerTrnMs256NSFsid,
- SynthesizerTrnMs256NSFsid_nono,
- SynthesizerTrnMs768NSFsid,
- SynthesizerTrnMs768NSFsid_nono,
-)
-from infer.lib.audio import load_audio
-from fairseq import checkpoint_utils
-from scipy.io import wavfile
-
-hubert_model = None
-
-
-def load_hubert():
- global hubert_model
- models, saved_cfg, task = checkpoint_utils.load_model_ensemble_and_task(
- ["hubert_base.pt"],
- suffix="",
- )
- hubert_model = models[0]
- hubert_model = hubert_model.to(device)
- if is_half:
- hubert_model = hubert_model.half()
- else:
- hubert_model = hubert_model.float()
- hubert_model.eval()
-
-
-def vc_single(sid, input_audio, f0_up_key, f0_file, f0_method, file_index, index_rate):
- global tgt_sr, net_g, vc, hubert_model, version
- if input_audio is None:
- return "You need to upload an audio", None
- f0_up_key = int(f0_up_key)
- audio = load_audio(input_audio, 16000)
- times = [0, 0, 0]
- if hubert_model == None:
- load_hubert()
- if_f0 = cpt.get("f0", 1)
- # audio_opt=vc.pipeline(hubert_model,net_g,sid,audio,times,f0_up_key,f0_method,file_index,file_big_npy,index_rate,if_f0,f0_file=f0_file)
- audio_opt = vc.pipeline(
- hubert_model,
- net_g,
- sid,
- audio,
- input_audio,
- times,
- f0_up_key,
- f0_method,
- file_index,
- index_rate,
- if_f0,
- filter_radius,
- tgt_sr,
- resample_sr,
- rms_mix_rate,
- version,
- protect,
- f0_file=f0_file,
- )
- print(times)
- return audio_opt
-
-
-def get_vc(model_path):
- global n_spk, tgt_sr, net_g, vc, cpt, device, is_half, version
- print("loading pth %s" % model_path)
- cpt = torch.load(model_path, map_location="cpu")
- tgt_sr = cpt["config"][-1]
- cpt["config"][-3] = cpt["weight"]["emb_g.weight"].shape[0] # n_spk
- if_f0 = cpt.get("f0", 1)
- version = cpt.get("version", "v1")
- if version == "v1":
- if if_f0 == 1:
- net_g = SynthesizerTrnMs256NSFsid(*cpt["config"], is_half=is_half)
- else:
- net_g = SynthesizerTrnMs256NSFsid_nono(*cpt["config"])
- elif version == "v2":
- if if_f0 == 1: #
- net_g = SynthesizerTrnMs768NSFsid(*cpt["config"], is_half=is_half)
- else:
- net_g = SynthesizerTrnMs768NSFsid_nono(*cpt["config"])
- del net_g.enc_q
- print(net_g.load_state_dict(cpt["weight"], strict=False)) # 不加这一行清不干净，真奇葩
- net_g.eval().to(device)
- if is_half:
- net_g = net_g.half()
- else:
- net_g = net_g.float()
- vc = VC(tgt_sr, config)
- n_spk = cpt["config"][-3]
- # return {"visible": True,"maximum": n_spk, "__type__": "update"}
-
-
-get_vc(model_path)
-audios = os.listdir(input_path)
-for file in tq.tqdm(audios):
- if file.endswith(".wav"):
- file_path = input_path + "/" + file
- wav_opt = vc_single(
- 0, file_path, f0up_key, None, f0method, index_path, index_rate
- )
- out_path = opt_path + "/" + file
- wavfile.write(out_path, tgt_sr, wav_opt)
diff --git a/spaces/Bart92/RVC_HF/lib/uvr5_pack/lib_v5/dataset.py b/spaces/Bart92/RVC_HF/lib/uvr5_pack/lib_v5/dataset.py
deleted file mode 100644
index cfd01a174978d97180a897e40cb59ecadec1d12e..0000000000000000000000000000000000000000
--- a/spaces/Bart92/RVC_HF/lib/uvr5_pack/lib_v5/dataset.py
+++ /dev/null
@@ -1,183 +0,0 @@
-import os
-import random
-
-import numpy as np
-import torch
-import torch.utils.data
-from tqdm import tqdm
-
-from . import spec_utils
-
-
-class VocalRemoverValidationSet(torch.utils.data.Dataset):
- def __init__(self, patch_list):
- self.patch_list = patch_list
-
- def __len__(self):
- return len(self.patch_list)
-
- def __getitem__(self, idx):
- path = self.patch_list[idx]
- data = np.load(path)
-
- X, y = data["X"], data["y"]
-
- X_mag = np.abs(X)
- y_mag = np.abs(y)
-
- return X_mag, y_mag
-
-
-def make_pair(mix_dir, inst_dir):
- input_exts = [".wav", ".m4a", ".mp3", ".mp4", ".flac"]
-
- X_list = sorted(
- [
- os.path.join(mix_dir, fname)
- for fname in os.listdir(mix_dir)
- if os.path.splitext(fname)[1] in input_exts
- ]
- )
- y_list = sorted(
- [
- os.path.join(inst_dir, fname)
- for fname in os.listdir(inst_dir)
- if os.path.splitext(fname)[1] in input_exts
- ]
- )
-
- filelist = list(zip(X_list, y_list))
-
- return filelist
-
-
-def train_val_split(dataset_dir, split_mode, val_rate, val_filelist):
- if split_mode == "random":
- filelist = make_pair(
- os.path.join(dataset_dir, "mixtures"),
- os.path.join(dataset_dir, "instruments"),
- )
-
- random.shuffle(filelist)
-
- if len(val_filelist) == 0:
- val_size = int(len(filelist) * val_rate)
- train_filelist = filelist[:-val_size]
- val_filelist = filelist[-val_size:]
- else:
- train_filelist = [
- pair for pair in filelist if list(pair) not in val_filelist
- ]
- elif split_mode == "subdirs":
- if len(val_filelist) != 0:
- raise ValueError(
- "The `val_filelist` option is not available in `subdirs` mode"
- )
-
- train_filelist = make_pair(
- os.path.join(dataset_dir, "training/mixtures"),
- os.path.join(dataset_dir, "training/instruments"),
- )
-
- val_filelist = make_pair(
- os.path.join(dataset_dir, "validation/mixtures"),
- os.path.join(dataset_dir, "validation/instruments"),
- )
-
- return train_filelist, val_filelist
-
-
-def augment(X, y, reduction_rate, reduction_mask, mixup_rate, mixup_alpha):
- perm = np.random.permutation(len(X))
- for i, idx in enumerate(tqdm(perm)):
- if np.random.uniform() < reduction_rate:
- y[idx] = spec_utils.reduce_vocal_aggressively(
- X[idx], y[idx], reduction_mask
- )
-
- if np.random.uniform() < 0.5:
- # swap channel
- X[idx] = X[idx, ::-1]
- y[idx] = y[idx, ::-1]
- if np.random.uniform() < 0.02:
- # mono
- X[idx] = X[idx].mean(axis=0, keepdims=True)
- y[idx] = y[idx].mean(axis=0, keepdims=True)
- if np.random.uniform() < 0.02:
- # inst
- X[idx] = y[idx]
-
- if np.random.uniform() < mixup_rate and i < len(perm) - 1:
- lam = np.random.beta(mixup_alpha, mixup_alpha)
- X[idx] = lam * X[idx] + (1 - lam) * X[perm[i + 1]]
- y[idx] = lam * y[idx] + (1 - lam) * y[perm[i + 1]]
-
- return X, y
-
-
-def make_padding(width, cropsize, offset):
- left = offset
- roi_size = cropsize - left * 2
- if roi_size == 0:
- roi_size = cropsize
- right = roi_size - (width % roi_size) + left
-
- return left, right, roi_size
-
-
-def make_training_set(filelist, cropsize, patches, sr, hop_length, n_fft, offset):
- len_dataset = patches * len(filelist)
-
- X_dataset = np.zeros((len_dataset, 2, n_fft // 2 + 1, cropsize), dtype=np.complex64)
- y_dataset = np.zeros((len_dataset, 2, n_fft // 2 + 1, cropsize), dtype=np.complex64)
-
- for i, (X_path, y_path) in enumerate(tqdm(filelist)):
- X, y = spec_utils.cache_or_load(X_path, y_path, sr, hop_length, n_fft)
- coef = np.max([np.abs(X).max(), np.abs(y).max()])
- X, y = X / coef, y / coef
-
- l, r, roi_size = make_padding(X.shape[2], cropsize, offset)
- X_pad = np.pad(X, ((0, 0), (0, 0), (l, r)), mode="constant")
- y_pad = np.pad(y, ((0, 0), (0, 0), (l, r)), mode="constant")
-
- starts = np.random.randint(0, X_pad.shape[2] - cropsize, patches)
- ends = starts + cropsize
- for j in range(patches):
- idx = i * patches + j
- X_dataset[idx] = X_pad[:, :, starts[j] : ends[j]]
- y_dataset[idx] = y_pad[:, :, starts[j] : ends[j]]
-
- return X_dataset, y_dataset
-
-
-def make_validation_set(filelist, cropsize, sr, hop_length, n_fft, offset):
- patch_list = []
- patch_dir = "cs{}_sr{}_hl{}_nf{}_of{}".format(
- cropsize, sr, hop_length, n_fft, offset
- )
- os.makedirs(patch_dir, exist_ok=True)
-
- for i, (X_path, y_path) in enumerate(tqdm(filelist)):
- basename = os.path.splitext(os.path.basename(X_path))[0]
-
- X, y = spec_utils.cache_or_load(X_path, y_path, sr, hop_length, n_fft)
- coef = np.max([np.abs(X).max(), np.abs(y).max()])
- X, y = X / coef, y / coef
-
- l, r, roi_size = make_padding(X.shape[2], cropsize, offset)
- X_pad = np.pad(X, ((0, 0), (0, 0), (l, r)), mode="constant")
- y_pad = np.pad(y, ((0, 0), (0, 0), (l, r)), mode="constant")
-
- len_dataset = int(np.ceil(X.shape[2] / roi_size))
- for j in range(len_dataset):
- outpath = os.path.join(patch_dir, "{}_p{}.npz".format(basename, j))
- start = j * roi_size
- if not os.path.exists(outpath):
- np.savez(
- outpath,
- X=X_pad[:, :, start : start + cropsize],
- y=y_pad[:, :, start : start + cropsize],
- )
- patch_list.append(outpath)
-
- return VocalRemoverValidationSet(patch_list)
diff --git a/spaces/Belshia/shia/README.md b/spaces/Belshia/shia/README.md
deleted file mode 100644
index d648421b8ee540f3bcef13291fa6200bf34345cb..0000000000000000000000000000000000000000
--- a/spaces/Belshia/shia/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Shia
-emoji: 🌍
-colorFrom: purple
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.39.0
-app_file: app.py
-pinned: false
-license: openrail
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Big-Web/MMSD/env/Lib/site-packages/dateutil/_version.py b/spaces/Big-Web/MMSD/env/Lib/site-packages/dateutil/_version.py
deleted file mode 100644
index b723056a756af22aaf1a4709c5122bea9fb279ee..0000000000000000000000000000000000000000
--- a/spaces/Big-Web/MMSD/env/Lib/site-packages/dateutil/_version.py
+++ /dev/null
@@ -1,5 +0,0 @@
-# coding: utf-8
-# file generated by setuptools_scm
-# don't change, don't track in version control
-version = '2.8.2'
-version_tuple = (2, 8, 2)
diff --git a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/urllib3/poolmanager.py b/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/urllib3/poolmanager.py
deleted file mode 100644
index ca4ec341184adb3d30f3cd825b49a81b87d29b08..0000000000000000000000000000000000000000
--- a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/urllib3/poolmanager.py
+++ /dev/null
@@ -1,537 +0,0 @@
-from __future__ import absolute_import
-
-import collections
-import functools
-import logging
-
-from ._collections import RecentlyUsedContainer
-from .connectionpool import HTTPConnectionPool, HTTPSConnectionPool, port_by_scheme
-from .exceptions import (
- LocationValueError,
- MaxRetryError,
- ProxySchemeUnknown,
- ProxySchemeUnsupported,
- URLSchemeUnknown,
-)
-from .packages import six
-from .packages.six.moves.urllib.parse import urljoin
-from .request import RequestMethods
-from .util.proxy import connection_requires_http_tunnel
-from .util.retry import Retry
-from .util.url import parse_url
-
-__all__ = ["PoolManager", "ProxyManager", "proxy_from_url"]
-
-
-log = logging.getLogger(__name__)
-
-SSL_KEYWORDS = (
- "key_file",
- "cert_file",
- "cert_reqs",
- "ca_certs",
- "ssl_version",
- "ca_cert_dir",
- "ssl_context",
- "key_password",
- "server_hostname",
-)
-
-# All known keyword arguments that could be provided to the pool manager, its
-# pools, or the underlying connections. This is used to construct a pool key.
-_key_fields = (
- "key_scheme", # str
- "key_host", # str
- "key_port", # int
- "key_timeout", # int or float or Timeout
- "key_retries", # int or Retry
- "key_strict", # bool
- "key_block", # bool
- "key_source_address", # str
- "key_key_file", # str
- "key_key_password", # str
- "key_cert_file", # str
- "key_cert_reqs", # str
- "key_ca_certs", # str
- "key_ssl_version", # str
- "key_ca_cert_dir", # str
- "key_ssl_context", # instance of ssl.SSLContext or urllib3.util.ssl_.SSLContext
- "key_maxsize", # int
- "key_headers", # dict
- "key__proxy", # parsed proxy url
- "key__proxy_headers", # dict
- "key__proxy_config", # class
- "key_socket_options", # list of (level (int), optname (int), value (int or str)) tuples
- "key__socks_options", # dict
- "key_assert_hostname", # bool or string
- "key_assert_fingerprint", # str
- "key_server_hostname", # str
-)
-
-#: The namedtuple class used to construct keys for the connection pool.
-#: All custom key schemes should include the fields in this key at a minimum.
-PoolKey = collections.namedtuple("PoolKey", _key_fields)
-
-_proxy_config_fields = ("ssl_context", "use_forwarding_for_https")
-ProxyConfig = collections.namedtuple("ProxyConfig", _proxy_config_fields)
-
-
-def _default_key_normalizer(key_class, request_context):
- """
- Create a pool key out of a request context dictionary.
-
- According to RFC 3986, both the scheme and host are case-insensitive.
- Therefore, this function normalizes both before constructing the pool
- key for an HTTPS request. If you wish to change this behaviour, provide
- alternate callables to ``key_fn_by_scheme``.
-
- :param key_class:
- The class to use when constructing the key. This should be a namedtuple
- with the ``scheme`` and ``host`` keys at a minimum.
- :type key_class: namedtuple
- :param request_context:
- A dictionary-like object that contain the context for a request.
- :type request_context: dict
-
- :return: A namedtuple that can be used as a connection pool key.
- :rtype: PoolKey
- """
- # Since we mutate the dictionary, make a copy first
- context = request_context.copy()
- context["scheme"] = context["scheme"].lower()
- context["host"] = context["host"].lower()
-
- # These are both dictionaries and need to be transformed into frozensets
- for key in ("headers", "_proxy_headers", "_socks_options"):
- if key in context and context[key] is not None:
- context[key] = frozenset(context[key].items())
-
- # The socket_options key may be a list and needs to be transformed into a
- # tuple.
- socket_opts = context.get("socket_options")
- if socket_opts is not None:
- context["socket_options"] = tuple(socket_opts)
-
- # Map the kwargs to the names in the namedtuple - this is necessary since
- # namedtuples can't have fields starting with '_'.
- for key in list(context.keys()):
- context["key_" + key] = context.pop(key)
-
- # Default to ``None`` for keys missing from the context
- for field in key_class._fields:
- if field not in context:
- context[field] = None
-
- return key_class(**context)
-
-
-#: A dictionary that maps a scheme to a callable that creates a pool key.
-#: This can be used to alter the way pool keys are constructed, if desired.
-#: Each PoolManager makes a copy of this dictionary so they can be configured
-#: globally here, or individually on the instance.
-key_fn_by_scheme = {
- "http": functools.partial(_default_key_normalizer, PoolKey),
- "https": functools.partial(_default_key_normalizer, PoolKey),
-}
-
-pool_classes_by_scheme = {"http": HTTPConnectionPool, "https": HTTPSConnectionPool}
-
-
-class PoolManager(RequestMethods):
- """
- Allows for arbitrary requests while transparently keeping track of
- necessary connection pools for you.
-
- :param num_pools:
- Number of connection pools to cache before discarding the least
- recently used pool.
-
- :param headers:
- Headers to include with all requests, unless other headers are given
- explicitly.
-
- :param \\**connection_pool_kw:
- Additional parameters are used to create fresh
- :class:`urllib3.connectionpool.ConnectionPool` instances.
-
- Example::
-
- >>> manager = PoolManager(num_pools=2)
- >>> r = manager.request('GET', 'http://google.com/')
- >>> r = manager.request('GET', 'http://google.com/mail')
- >>> r = manager.request('GET', 'http://yahoo.com/')
- >>> len(manager.pools)
- 2
-
- """
-
- proxy = None
- proxy_config = None
-
- def __init__(self, num_pools=10, headers=None, **connection_pool_kw):
- RequestMethods.__init__(self, headers)
- self.connection_pool_kw = connection_pool_kw
- self.pools = RecentlyUsedContainer(num_pools, dispose_func=lambda p: p.close())
-
- # Locally set the pool classes and keys so other PoolManagers can
- # override them.
- self.pool_classes_by_scheme = pool_classes_by_scheme
- self.key_fn_by_scheme = key_fn_by_scheme.copy()
-
- def __enter__(self):
- return self
-
- def __exit__(self, exc_type, exc_val, exc_tb):
- self.clear()
- # Return False to re-raise any potential exceptions
- return False
-
- def _new_pool(self, scheme, host, port, request_context=None):
- """
- Create a new :class:`urllib3.connectionpool.ConnectionPool` based on host, port, scheme, and
- any additional pool keyword arguments.
-
- If ``request_context`` is provided, it is provided as keyword arguments
- to the pool class used. This method is used to actually create the
- connection pools handed out by :meth:`connection_from_url` and
- companion methods. It is intended to be overridden for customization.
- """
- pool_cls = self.pool_classes_by_scheme[scheme]
- if request_context is None:
- request_context = self.connection_pool_kw.copy()
-
- # Although the context has everything necessary to create the pool,
- # this function has historically only used the scheme, host, and port
- # in the positional args. When an API change is acceptable these can
- # be removed.
- for key in ("scheme", "host", "port"):
- request_context.pop(key, None)
-
- if scheme == "http":
- for kw in SSL_KEYWORDS:
- request_context.pop(kw, None)
-
- return pool_cls(host, port, **request_context)
-
- def clear(self):
- """
- Empty our store of pools and direct them all to close.
-
- This will not affect in-flight connections, but they will not be
- re-used after completion.
- """
- self.pools.clear()
-
- def connection_from_host(self, host, port=None, scheme="http", pool_kwargs=None):
- """
- Get a :class:`urllib3.connectionpool.ConnectionPool` based on the host, port, and scheme.
-
- If ``port`` isn't given, it will be derived from the ``scheme`` using
- ``urllib3.connectionpool.port_by_scheme``. If ``pool_kwargs`` is
- provided, it is merged with the instance's ``connection_pool_kw``
- variable and used to create the new connection pool, if one is
- needed.
- """
-
- if not host:
- raise LocationValueError("No host specified.")
-
- request_context = self._merge_pool_kwargs(pool_kwargs)
- request_context["scheme"] = scheme or "http"
- if not port:
- port = port_by_scheme.get(request_context["scheme"].lower(), 80)
- request_context["port"] = port
- request_context["host"] = host
-
- return self.connection_from_context(request_context)
-
- def connection_from_context(self, request_context):
- """
- Get a :class:`urllib3.connectionpool.ConnectionPool` based on the request context.
-
- ``request_context`` must at least contain the ``scheme`` key and its
- value must be a key in ``key_fn_by_scheme`` instance variable.
- """
- scheme = request_context["scheme"].lower()
- pool_key_constructor = self.key_fn_by_scheme.get(scheme)
- if not pool_key_constructor:
- raise URLSchemeUnknown(scheme)
- pool_key = pool_key_constructor(request_context)
-
- return self.connection_from_pool_key(pool_key, request_context=request_context)
-
- def connection_from_pool_key(self, pool_key, request_context=None):
- """
- Get a :class:`urllib3.connectionpool.ConnectionPool` based on the provided pool key.
-
- ``pool_key`` should be a namedtuple that only contains immutable
- objects. At a minimum it must have the ``scheme``, ``host``, and
- ``port`` fields.
- """
- with self.pools.lock:
- # If the scheme, host, or port doesn't match existing open
- # connections, open a new ConnectionPool.
- pool = self.pools.get(pool_key)
- if pool:
- return pool
-
- # Make a fresh ConnectionPool of the desired type
- scheme = request_context["scheme"]
- host = request_context["host"]
- port = request_context["port"]
- pool = self._new_pool(scheme, host, port, request_context=request_context)
- self.pools[pool_key] = pool
-
- return pool
-
- def connection_from_url(self, url, pool_kwargs=None):
- """
- Similar to :func:`urllib3.connectionpool.connection_from_url`.
-
- If ``pool_kwargs`` is not provided and a new pool needs to be
- constructed, ``self.connection_pool_kw`` is used to initialize
- the :class:`urllib3.connectionpool.ConnectionPool`. If ``pool_kwargs``
- is provided, it is used instead. Note that if a new pool does not
- need to be created for the request, the provided ``pool_kwargs`` are
- not used.
- """
- u = parse_url(url)
- return self.connection_from_host(
- u.host, port=u.port, scheme=u.scheme, pool_kwargs=pool_kwargs
- )
-
- def _merge_pool_kwargs(self, override):
- """
- Merge a dictionary of override values for self.connection_pool_kw.
-
- This does not modify self.connection_pool_kw and returns a new dict.
- Any keys in the override dictionary with a value of ``None`` are
- removed from the merged dictionary.
- """
- base_pool_kwargs = self.connection_pool_kw.copy()
- if override:
- for key, value in override.items():
- if value is None:
- try:
- del base_pool_kwargs[key]
- except KeyError:
- pass
- else:
- base_pool_kwargs[key] = value
- return base_pool_kwargs
-
- def _proxy_requires_url_absolute_form(self, parsed_url):
- """
- Indicates if the proxy requires the complete destination URL in the
- request. Normally this is only needed when not using an HTTP CONNECT
- tunnel.
- """
- if self.proxy is None:
- return False
-
- return not connection_requires_http_tunnel(
- self.proxy, self.proxy_config, parsed_url.scheme
- )
-
- def _validate_proxy_scheme_url_selection(self, url_scheme):
- """
- Validates that were not attempting to do TLS in TLS connections on
- Python2 or with unsupported SSL implementations.
- """
- if self.proxy is None or url_scheme != "https":
- return
-
- if self.proxy.scheme != "https":
- return
-
- if six.PY2 and not self.proxy_config.use_forwarding_for_https:
- raise ProxySchemeUnsupported(
- "Contacting HTTPS destinations through HTTPS proxies "
- "'via CONNECT tunnels' is not supported in Python 2"
- )
-
- def urlopen(self, method, url, redirect=True, **kw):
- """
- Same as :meth:`urllib3.HTTPConnectionPool.urlopen`
- with custom cross-host redirect logic and only sends the request-uri
- portion of the ``url``.
-
- The given ``url`` parameter must be absolute, such that an appropriate
- :class:`urllib3.connectionpool.ConnectionPool` can be chosen for it.
- """
- u = parse_url(url)
- self._validate_proxy_scheme_url_selection(u.scheme)
-
- conn = self.connection_from_host(u.host, port=u.port, scheme=u.scheme)
-
- kw["assert_same_host"] = False
- kw["redirect"] = False
-
- if "headers" not in kw:
- kw["headers"] = self.headers.copy()
-
- if self._proxy_requires_url_absolute_form(u):
- response = conn.urlopen(method, url, **kw)
- else:
- response = conn.urlopen(method, u.request_uri, **kw)
-
- redirect_location = redirect and response.get_redirect_location()
- if not redirect_location:
- return response
-
- # Support relative URLs for redirecting.
- redirect_location = urljoin(url, redirect_location)
-
- # RFC 7231, Section 6.4.4
- if response.status == 303:
- method = "GET"
-
- retries = kw.get("retries")
- if not isinstance(retries, Retry):
- retries = Retry.from_int(retries, redirect=redirect)
-
- # Strip headers marked as unsafe to forward to the redirected location.
- # Check remove_headers_on_redirect to avoid a potential network call within
- # conn.is_same_host() which may use socket.gethostbyname() in the future.
- if retries.remove_headers_on_redirect and not conn.is_same_host(
- redirect_location
- ):
- headers = list(six.iterkeys(kw["headers"]))
- for header in headers:
- if header.lower() in retries.remove_headers_on_redirect:
- kw["headers"].pop(header, None)
-
- try:
- retries = retries.increment(method, url, response=response, _pool=conn)
- except MaxRetryError:
- if retries.raise_on_redirect:
- response.drain_conn()
- raise
- return response
-
- kw["retries"] = retries
- kw["redirect"] = redirect
-
- log.info("Redirecting %s -> %s", url, redirect_location)
-
- response.drain_conn()
- return self.urlopen(method, redirect_location, **kw)
-
-
-class ProxyManager(PoolManager):
- """
- Behaves just like :class:`PoolManager`, but sends all requests through
- the defined proxy, using the CONNECT method for HTTPS URLs.
-
- :param proxy_url:
- The URL of the proxy to be used.
-
- :param proxy_headers:
- A dictionary containing headers that will be sent to the proxy. In case
- of HTTP they are being sent with each request, while in the
- HTTPS/CONNECT case they are sent only once. Could be used for proxy
- authentication.
-
- :param proxy_ssl_context:
- The proxy SSL context is used to establish the TLS connection to the
- proxy when using HTTPS proxies.
-
- :param use_forwarding_for_https:
- (Defaults to False) If set to True will forward requests to the HTTPS
- proxy to be made on behalf of the client instead of creating a TLS
- tunnel via the CONNECT method. **Enabling this flag means that request
- and response headers and content will be visible from the HTTPS proxy**
- whereas tunneling keeps request and response headers and content
- private. IP address, target hostname, SNI, and port are always visible
- to an HTTPS proxy even when this flag is disabled.
-
- Example:
- >>> proxy = urllib3.ProxyManager('http://localhost:3128/')
- >>> r1 = proxy.request('GET', 'http://google.com/')
- >>> r2 = proxy.request('GET', 'http://httpbin.org/')
- >>> len(proxy.pools)
- 1
- >>> r3 = proxy.request('GET', 'https://httpbin.org/')
- >>> r4 = proxy.request('GET', 'https://twitter.com/')
- >>> len(proxy.pools)
- 3
-
- """
-
- def __init__(
- self,
- proxy_url,
- num_pools=10,
- headers=None,
- proxy_headers=None,
- proxy_ssl_context=None,
- use_forwarding_for_https=False,
- **connection_pool_kw
- ):
-
- if isinstance(proxy_url, HTTPConnectionPool):
- proxy_url = "%s://%s:%i" % (
- proxy_url.scheme,
- proxy_url.host,
- proxy_url.port,
- )
- proxy = parse_url(proxy_url)
-
- if proxy.scheme not in ("http", "https"):
- raise ProxySchemeUnknown(proxy.scheme)
-
- if not proxy.port:
- port = port_by_scheme.get(proxy.scheme, 80)
- proxy = proxy._replace(port=port)
-
- self.proxy = proxy
- self.proxy_headers = proxy_headers or {}
- self.proxy_ssl_context = proxy_ssl_context
- self.proxy_config = ProxyConfig(proxy_ssl_context, use_forwarding_for_https)
-
- connection_pool_kw["_proxy"] = self.proxy
- connection_pool_kw["_proxy_headers"] = self.proxy_headers
- connection_pool_kw["_proxy_config"] = self.proxy_config
-
- super(ProxyManager, self).__init__(num_pools, headers, **connection_pool_kw)
-
- def connection_from_host(self, host, port=None, scheme="http", pool_kwargs=None):
- if scheme == "https":
- return super(ProxyManager, self).connection_from_host(
- host, port, scheme, pool_kwargs=pool_kwargs
- )
-
- return super(ProxyManager, self).connection_from_host(
- self.proxy.host, self.proxy.port, self.proxy.scheme, pool_kwargs=pool_kwargs
- )
-
- def _set_proxy_headers(self, url, headers=None):
- """
- Sets headers needed by proxies: specifically, the Accept and Host
- headers. Only sets headers not provided by the user.
- """
- headers_ = {"Accept": "*/*"}
-
- netloc = parse_url(url).netloc
- if netloc:
- headers_["Host"] = netloc
-
- if headers:
- headers_.update(headers)
- return headers_
-
- def urlopen(self, method, url, redirect=True, **kw):
- "Same as HTTP(S)ConnectionPool.urlopen, ``url`` must be absolute."
- u = parse_url(url)
- if not connection_requires_http_tunnel(self.proxy, self.proxy_config, u.scheme):
- # For connections using HTTP CONNECT, httplib sets the necessary
- # headers on the CONNECT to the proxy. If we're not using CONNECT,
- # we'll definitely need to set 'Host' at the very least.
- headers = kw.get("headers", self.headers)
- kw["headers"] = self._set_proxy_headers(url, headers)
-
- return super(ProxyManager, self).urlopen(method, url, redirect=redirect, **kw)
-
-
-def proxy_from_url(url, **kw):
- return ProxyManager(proxy_url=url, **kw)
diff --git a/spaces/Boadiwaa/Recipes/openai/api_resources/experimental/completion_config.py b/spaces/Boadiwaa/Recipes/openai/api_resources/experimental/completion_config.py
deleted file mode 100644
index 5d4feb40e1bcba470690e888473d9b7623b4282d..0000000000000000000000000000000000000000
--- a/spaces/Boadiwaa/Recipes/openai/api_resources/experimental/completion_config.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from openai.api_resources.abstract import (
- CreateableAPIResource,
- DeletableAPIResource,
- ListableAPIResource,
-)
-
-
-class CompletionConfig(
- CreateableAPIResource, ListableAPIResource, DeletableAPIResource
-):
- OBJECT_NAME = "experimental.completion_configs"
diff --git a/spaces/CVPR/LIVE/thrust/thrust/system/tbb/detail/unique_by_key.h b/spaces/CVPR/LIVE/thrust/thrust/system/tbb/detail/unique_by_key.h
deleted file mode 100644
index 6ab8578407e1cd90aeaba982780b966b4aee013e..0000000000000000000000000000000000000000
--- a/spaces/CVPR/LIVE/thrust/thrust/system/tbb/detail/unique_by_key.h
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright 2008-2013 NVIDIA Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include
-
- """
- )
-
- with gr.Row():
-
- # Left column (lyrics generation)
- with gr.Column():
- with gr.Accordion("Step 1. Generate Lyrics"):
- gr.Markdown("Enter the starting text and select genre to generate lyrics")
- with gr.Row():
- input_start_text = gr.Textbox(placeholder='I am', label="Starting Text")
- input_lyrics_type = gr.Radio(choices=['pop', 'rap', 'country', 'rock', 'r&b'], value='pop', label="Lyrics Genre")
- button_gen_lyrics = gr.Button("Generate Lyrics", variant="primary")
- output_generated_lyrics = gr.Textbox(label="Generated Lyrics", lines=8)
-
- # Right column (single cover generation)
- with gr.Column():
- with gr.Accordion("Step 2. Generate Single Cover"):
- gr.Markdown("Cover will be generated based on style, effect and generated lyrics")
- with gr.Row():
- input_cover_style = gr.Dropdown(choices=['painted', 'abstract', 'minimalist', 'illustrated', 'photographic', 'vintage'], value='painted', label="Track Cover Style")
- input_cover_effect = gr.Radio(choices=['black and white', 'highly detailed', 'blurred'], value='highly detailed', label="Track Cover Effect")
- button_gen_cover = gr.Button("Generate Cover", variant="primary")
- output_generated_cover = gr.Image(label="Generated Cover")
-
- # Bind functions to buttons
- button_gen_lyrics.click(fn=generate_lyrics, inputs=[input_lyrics_type , input_start_text], outputs=output_generated_lyrics)
- button_gen_cover.click(fn=generate_cover, inputs=[output_generated_lyrics, input_cover_style, input_cover_effect], outputs=output_generated_cover)
-
-demo.launch(debug=True)
\ No newline at end of file
diff --git a/spaces/FridaZuley/RVC_HFKawaii/infer/lib/infer_pack/modules.py b/spaces/FridaZuley/RVC_HFKawaii/infer/lib/infer_pack/modules.py
deleted file mode 100644
index 2201a58bee9b7808d386b3ef9ac2d1f9630e56ef..0000000000000000000000000000000000000000
--- a/spaces/FridaZuley/RVC_HFKawaii/infer/lib/infer_pack/modules.py
+++ /dev/null
@@ -1,521 +0,0 @@
-import copy
-import math
-
-import numpy as np
-import scipy
-import torch
-from torch import nn
-from torch.nn import AvgPool1d, Conv1d, Conv2d, ConvTranspose1d
-from torch.nn import functional as F
-from torch.nn.utils import remove_weight_norm, weight_norm
-
-from infer.lib.infer_pack import commons
-from infer.lib.infer_pack.commons import get_padding, init_weights
-from infer.lib.infer_pack.transforms import piecewise_rational_quadratic_transform
-
-LRELU_SLOPE = 0.1
-
-
-class LayerNorm(nn.Module):
- def __init__(self, channels, eps=1e-5):
- super().__init__()
- self.channels = channels
- self.eps = eps
-
- self.gamma = nn.Parameter(torch.ones(channels))
- self.beta = nn.Parameter(torch.zeros(channels))
-
- def forward(self, x):
- x = x.transpose(1, -1)
- x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
- return x.transpose(1, -1)
-
-
-class ConvReluNorm(nn.Module):
- def __init__(
- self,
- in_channels,
- hidden_channels,
- out_channels,
- kernel_size,
- n_layers,
- p_dropout,
- ):
- super().__init__()
- self.in_channels = in_channels
- self.hidden_channels = hidden_channels
- self.out_channels = out_channels
- self.kernel_size = kernel_size
- self.n_layers = n_layers
- self.p_dropout = p_dropout
- assert n_layers > 1, "Number of layers should be larger than 0."
-
- self.conv_layers = nn.ModuleList()
- self.norm_layers = nn.ModuleList()
- self.conv_layers.append(
- nn.Conv1d(
- in_channels, hidden_channels, kernel_size, padding=kernel_size // 2
- )
- )
- self.norm_layers.append(LayerNorm(hidden_channels))
- self.relu_drop = nn.Sequential(nn.ReLU(), nn.Dropout(p_dropout))
- for _ in range(n_layers - 1):
- self.conv_layers.append(
- nn.Conv1d(
- hidden_channels,
- hidden_channels,
- kernel_size,
- padding=kernel_size // 2,
- )
- )
- self.norm_layers.append(LayerNorm(hidden_channels))
- self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
- self.proj.weight.data.zero_()
- self.proj.bias.data.zero_()
-
- def forward(self, x, x_mask):
- x_org = x
- for i in range(self.n_layers):
- x = self.conv_layers[i](x * x_mask)
- x = self.norm_layers[i](x)
- x = self.relu_drop(x)
- x = x_org + self.proj(x)
- return x * x_mask
-
-
-class DDSConv(nn.Module):
- """
- Dialted and Depth-Separable Convolution
- """
-
- def __init__(self, channels, kernel_size, n_layers, p_dropout=0.0):
- super().__init__()
- self.channels = channels
- self.kernel_size = kernel_size
- self.n_layers = n_layers
- self.p_dropout = p_dropout
-
- self.drop = nn.Dropout(p_dropout)
- self.convs_sep = nn.ModuleList()
- self.convs_1x1 = nn.ModuleList()
- self.norms_1 = nn.ModuleList()
- self.norms_2 = nn.ModuleList()
- for i in range(n_layers):
- dilation = kernel_size**i
- padding = (kernel_size * dilation - dilation) // 2
- self.convs_sep.append(
- nn.Conv1d(
- channels,
- channels,
- kernel_size,
- groups=channels,
- dilation=dilation,
- padding=padding,
- )
- )
- self.convs_1x1.append(nn.Conv1d(channels, channels, 1))
- self.norms_1.append(LayerNorm(channels))
- self.norms_2.append(LayerNorm(channels))
-
- def forward(self, x, x_mask, g=None):
- if g is not None:
- x = x + g
- for i in range(self.n_layers):
- y = self.convs_sep[i](x * x_mask)
- y = self.norms_1[i](y)
- y = F.gelu(y)
- y = self.convs_1x1[i](y)
- y = self.norms_2[i](y)
- y = F.gelu(y)
- y = self.drop(y)
- x = x + y
- return x * x_mask
-
-
-class WN(torch.nn.Module):
- def __init__(
- self,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- gin_channels=0,
- p_dropout=0,
- ):
- super(WN, self).__init__()
- assert kernel_size % 2 == 1
- self.hidden_channels = hidden_channels
- self.kernel_size = (kernel_size,)
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.gin_channels = gin_channels
- self.p_dropout = p_dropout
-
- self.in_layers = torch.nn.ModuleList()
- self.res_skip_layers = torch.nn.ModuleList()
- self.drop = nn.Dropout(p_dropout)
-
- if gin_channels != 0:
- cond_layer = torch.nn.Conv1d(
- gin_channels, 2 * hidden_channels * n_layers, 1
- )
- self.cond_layer = torch.nn.utils.weight_norm(cond_layer, name="weight")
-
- for i in range(n_layers):
- dilation = dilation_rate**i
- padding = int((kernel_size * dilation - dilation) / 2)
- in_layer = torch.nn.Conv1d(
- hidden_channels,
- 2 * hidden_channels,
- kernel_size,
- dilation=dilation,
- padding=padding,
- )
- in_layer = torch.nn.utils.weight_norm(in_layer, name="weight")
- self.in_layers.append(in_layer)
-
- # last one is not necessary
- if i < n_layers - 1:
- res_skip_channels = 2 * hidden_channels
- else:
- res_skip_channels = hidden_channels
-
- res_skip_layer = torch.nn.Conv1d(hidden_channels, res_skip_channels, 1)
- res_skip_layer = torch.nn.utils.weight_norm(res_skip_layer, name="weight")
- self.res_skip_layers.append(res_skip_layer)
-
- def forward(self, x, x_mask, g=None, **kwargs):
- output = torch.zeros_like(x)
- n_channels_tensor = torch.IntTensor([self.hidden_channels])
-
- if g is not None:
- g = self.cond_layer(g)
-
- for i in range(self.n_layers):
- x_in = self.in_layers[i](x)
- if g is not None:
- cond_offset = i * 2 * self.hidden_channels
- g_l = g[:, cond_offset : cond_offset + 2 * self.hidden_channels, :]
- else:
- g_l = torch.zeros_like(x_in)
-
- acts = commons.fused_add_tanh_sigmoid_multiply(x_in, g_l, n_channels_tensor)
- acts = self.drop(acts)
-
- res_skip_acts = self.res_skip_layers[i](acts)
- if i < self.n_layers - 1:
- res_acts = res_skip_acts[:, : self.hidden_channels, :]
- x = (x + res_acts) * x_mask
- output = output + res_skip_acts[:, self.hidden_channels :, :]
- else:
- output = output + res_skip_acts
- return output * x_mask
-
- def remove_weight_norm(self):
- if self.gin_channels != 0:
- torch.nn.utils.remove_weight_norm(self.cond_layer)
- for l in self.in_layers:
- torch.nn.utils.remove_weight_norm(l)
- for l in self.res_skip_layers:
- torch.nn.utils.remove_weight_norm(l)
-
-
-class ResBlock1(torch.nn.Module):
- def __init__(self, channels, kernel_size=3, dilation=(1, 3, 5)):
- super(ResBlock1, self).__init__()
- self.convs1 = nn.ModuleList(
- [
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=dilation[0],
- padding=get_padding(kernel_size, dilation[0]),
- )
- ),
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=dilation[1],
- padding=get_padding(kernel_size, dilation[1]),
- )
- ),
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=dilation[2],
- padding=get_padding(kernel_size, dilation[2]),
- )
- ),
- ]
- )
- self.convs1.apply(init_weights)
-
- self.convs2 = nn.ModuleList(
- [
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=1,
- padding=get_padding(kernel_size, 1),
- )
- ),
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=1,
- padding=get_padding(kernel_size, 1),
- )
- ),
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=1,
- padding=get_padding(kernel_size, 1),
- )
- ),
- ]
- )
- self.convs2.apply(init_weights)
-
- def forward(self, x, x_mask=None):
- for c1, c2 in zip(self.convs1, self.convs2):
- xt = F.leaky_relu(x, LRELU_SLOPE)
- if x_mask is not None:
- xt = xt * x_mask
- xt = c1(xt)
- xt = F.leaky_relu(xt, LRELU_SLOPE)
- if x_mask is not None:
- xt = xt * x_mask
- xt = c2(xt)
- x = xt + x
- if x_mask is not None:
- x = x * x_mask
- return x
-
- def remove_weight_norm(self):
- for l in self.convs1:
- remove_weight_norm(l)
- for l in self.convs2:
- remove_weight_norm(l)
-
-
-class ResBlock2(torch.nn.Module):
- def __init__(self, channels, kernel_size=3, dilation=(1, 3)):
- super(ResBlock2, self).__init__()
- self.convs = nn.ModuleList(
- [
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=dilation[0],
- padding=get_padding(kernel_size, dilation[0]),
- )
- ),
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=dilation[1],
- padding=get_padding(kernel_size, dilation[1]),
- )
- ),
- ]
- )
- self.convs.apply(init_weights)
-
- def forward(self, x, x_mask=None):
- for c in self.convs:
- xt = F.leaky_relu(x, LRELU_SLOPE)
- if x_mask is not None:
- xt = xt * x_mask
- xt = c(xt)
- x = xt + x
- if x_mask is not None:
- x = x * x_mask
- return x
-
- def remove_weight_norm(self):
- for l in self.convs:
- remove_weight_norm(l)
-
-
-class Log(nn.Module):
- def forward(self, x, x_mask, reverse=False, **kwargs):
- if not reverse:
- y = torch.log(torch.clamp_min(x, 1e-5)) * x_mask
- logdet = torch.sum(-y, [1, 2])
- return y, logdet
- else:
- x = torch.exp(x) * x_mask
- return x
-
-
-class Flip(nn.Module):
- def forward(self, x, *args, reverse=False, **kwargs):
- x = torch.flip(x, [1])
- if not reverse:
- logdet = torch.zeros(x.size(0)).to(dtype=x.dtype, device=x.device)
- return x, logdet
- else:
- return x
-
-
-class ElementwiseAffine(nn.Module):
- def __init__(self, channels):
- super().__init__()
- self.channels = channels
- self.m = nn.Parameter(torch.zeros(channels, 1))
- self.logs = nn.Parameter(torch.zeros(channels, 1))
-
- def forward(self, x, x_mask, reverse=False, **kwargs):
- if not reverse:
- y = self.m + torch.exp(self.logs) * x
- y = y * x_mask
- logdet = torch.sum(self.logs * x_mask, [1, 2])
- return y, logdet
- else:
- x = (x - self.m) * torch.exp(-self.logs) * x_mask
- return x
-
-
-class ResidualCouplingLayer(nn.Module):
- def __init__(
- self,
- channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- p_dropout=0,
- gin_channels=0,
- mean_only=False,
- ):
- assert channels % 2 == 0, "channels should be divisible by 2"
- super().__init__()
- self.channels = channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.half_channels = channels // 2
- self.mean_only = mean_only
-
- self.pre = nn.Conv1d(self.half_channels, hidden_channels, 1)
- self.enc = WN(
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- p_dropout=p_dropout,
- gin_channels=gin_channels,
- )
- self.post = nn.Conv1d(hidden_channels, self.half_channels * (2 - mean_only), 1)
- self.post.weight.data.zero_()
- self.post.bias.data.zero_()
-
- def forward(self, x, x_mask, g=None, reverse=False):
- x0, x1 = torch.split(x, [self.half_channels] * 2, 1)
- h = self.pre(x0) * x_mask
- h = self.enc(h, x_mask, g=g)
- stats = self.post(h) * x_mask
- if not self.mean_only:
- m, logs = torch.split(stats, [self.half_channels] * 2, 1)
- else:
- m = stats
- logs = torch.zeros_like(m)
-
- if not reverse:
- x1 = m + x1 * torch.exp(logs) * x_mask
- x = torch.cat([x0, x1], 1)
- logdet = torch.sum(logs, [1, 2])
- return x, logdet
- else:
- x1 = (x1 - m) * torch.exp(-logs) * x_mask
- x = torch.cat([x0, x1], 1)
- return x
-
- def remove_weight_norm(self):
- self.enc.remove_weight_norm()
-
-
-class ConvFlow(nn.Module):
- def __init__(
- self,
- in_channels,
- filter_channels,
- kernel_size,
- n_layers,
- num_bins=10,
- tail_bound=5.0,
- ):
- super().__init__()
- self.in_channels = in_channels
- self.filter_channels = filter_channels
- self.kernel_size = kernel_size
- self.n_layers = n_layers
- self.num_bins = num_bins
- self.tail_bound = tail_bound
- self.half_channels = in_channels // 2
-
- self.pre = nn.Conv1d(self.half_channels, filter_channels, 1)
- self.convs = DDSConv(filter_channels, kernel_size, n_layers, p_dropout=0.0)
- self.proj = nn.Conv1d(
- filter_channels, self.half_channels * (num_bins * 3 - 1), 1
- )
- self.proj.weight.data.zero_()
- self.proj.bias.data.zero_()
-
- def forward(self, x, x_mask, g=None, reverse=False):
- x0, x1 = torch.split(x, [self.half_channels] * 2, 1)
- h = self.pre(x0)
- h = self.convs(h, x_mask, g=g)
- h = self.proj(h) * x_mask
-
- b, c, t = x0.shape
- h = h.reshape(b, c, -1, t).permute(0, 1, 3, 2) # [b, cx?, t] -> [b, c, t, ?]
-
- unnormalized_widths = h[..., : self.num_bins] / math.sqrt(self.filter_channels)
- unnormalized_heights = h[..., self.num_bins : 2 * self.num_bins] / math.sqrt(
- self.filter_channels
- )
- unnormalized_derivatives = h[..., 2 * self.num_bins :]
-
- x1, logabsdet = piecewise_rational_quadratic_transform(
- x1,
- unnormalized_widths,
- unnormalized_heights,
- unnormalized_derivatives,
- inverse=reverse,
- tails="linear",
- tail_bound=self.tail_bound,
- )
-
- x = torch.cat([x0, x1], 1) * x_mask
- logdet = torch.sum(logabsdet * x_mask, [1, 2])
- if not reverse:
- return x, logdet
- else:
- return x
diff --git a/spaces/FridaZuley/RVC_HFKawaii/infer/lib/infer_pack/modules/F0Predictor/PMF0Predictor.py b/spaces/FridaZuley/RVC_HFKawaii/infer/lib/infer_pack/modules/F0Predictor/PMF0Predictor.py
deleted file mode 100644
index 06f2b79f5e5c6f2049bf8220c29ae20c3f82d524..0000000000000000000000000000000000000000
--- a/spaces/FridaZuley/RVC_HFKawaii/infer/lib/infer_pack/modules/F0Predictor/PMF0Predictor.py
+++ /dev/null
@@ -1,98 +0,0 @@
-import numpy as np
-import parselmouth
-
-from infer.lib.infer_pack.modules.F0Predictor.F0Predictor import F0Predictor
-
-
-class PMF0Predictor(F0Predictor):
- def __init__(self, hop_length=512, f0_min=50, f0_max=1100, sampling_rate=44100):
- self.hop_length = hop_length
- self.f0_min = f0_min
- self.f0_max = f0_max
- self.sampling_rate = sampling_rate
-
- def interpolate_f0(self, f0):
- """
- 对F0进行插值处理
- """
-
- data = np.reshape(f0, (f0.size, 1))
-
- vuv_vector = np.zeros((data.size, 1), dtype=np.float32)
- vuv_vector[data > 0.0] = 1.0
- vuv_vector[data <= 0.0] = 0.0
-
- ip_data = data
-
- frame_number = data.size
- last_value = 0.0
- for i in range(frame_number):
- if data[i] <= 0.0:
- j = i + 1
- for j in range(i + 1, frame_number):
- if data[j] > 0.0:
- break
- if j < frame_number - 1:
- if last_value > 0.0:
- step = (data[j] - data[i - 1]) / float(j - i)
- for k in range(i, j):
- ip_data[k] = data[i - 1] + step * (k - i + 1)
- else:
- for k in range(i, j):
- ip_data[k] = data[j]
- else:
- for k in range(i, frame_number):
- ip_data[k] = last_value
- else:
- ip_data[i] = data[i] # 这里可能存在一个没有必要的拷贝
- last_value = data[i]
-
- return ip_data[:, 0], vuv_vector[:, 0]
-
- def compute_f0(self, wav, p_len=None):
- x = wav
- if p_len is None:
- p_len = x.shape[0] // self.hop_length
- else:
- assert abs(p_len - x.shape[0] // self.hop_length) < 4, "pad length error"
- time_step = self.hop_length / self.sampling_rate * 1000
- f0 = (
- parselmouth.Sound(x, self.sampling_rate)
- .to_pitch_ac(
- time_step=time_step / 1000,
- voicing_threshold=0.6,
- pitch_floor=self.f0_min,
- pitch_ceiling=self.f0_max,
- )
- .selected_array["frequency"]
- )
-
- pad_size = (p_len - len(f0) + 1) // 2
- if pad_size > 0 or p_len - len(f0) - pad_size > 0:
- f0 = np.pad(f0, [[pad_size, p_len - len(f0) - pad_size]], mode="constant")
- f0, uv = self.interpolate_f0(f0)
- return f0
-
- def compute_f0_uv(self, wav, p_len=None):
- x = wav
- if p_len is None:
- p_len = x.shape[0] // self.hop_length
- else:
- assert abs(p_len - x.shape[0] // self.hop_length) < 4, "pad length error"
- time_step = self.hop_length / self.sampling_rate * 1000
- f0 = (
- parselmouth.Sound(x, self.sampling_rate)
- .to_pitch_ac(
- time_step=time_step / 1000,
- voicing_threshold=0.6,
- pitch_floor=self.f0_min,
- pitch_ceiling=self.f0_max,
- )
- .selected_array["frequency"]
- )
-
- pad_size = (p_len - len(f0) + 1) // 2
- if pad_size > 0 or p_len - len(f0) - pad_size > 0:
- f0 = np.pad(f0, [[pad_size, p_len - len(f0) - pad_size]], mode="constant")
- f0, uv = self.interpolate_f0(f0)
- return f0, uv
diff --git a/spaces/GT-RIPL/GPT-K/knowledge/retrieve.py b/spaces/GT-RIPL/GPT-K/knowledge/retrieve.py
deleted file mode 100644
index 30126aadff6922c192d949feb95a60ef7890bab7..0000000000000000000000000000000000000000
--- a/spaces/GT-RIPL/GPT-K/knowledge/retrieve.py
+++ /dev/null
@@ -1,105 +0,0 @@
-import h5py
-import numpy as np
-from tqdm import tqdm
-import torch
-from knowledge import TextDB
-
-
-class ImageCropsIdx:
- def __init__(self, knowledge_idx, topk_w, topk_f, topk_n):
- topk = {"whole": topk_w, "five": topk_f, "nine": topk_n}
- self.topk = {k: v for k, v in topk.items() if v > 0}
-
- self.knowledge_idx, self.fdim, self.file_hash = self.load(knowledge_idx, self.topk)
-
- def load(self, knowledge_idx, topk):
- with h5py.File(knowledge_idx, "r") as f:
- fdim = f.attrs["fdim"]
- file_hash = f.attrs["file_hash"]
-
- knowledge_idx_ = {}
- for i in tqdm(range(len(f)), desc="Load sentence idx", dynamic_ncols=True, mininterval=1.0):
- knowledge_idx_[str(i)] = {"image_ids": f[f"{i}/image_ids"][:]}
- for k, v in topk.items():
- knowledge_idx_[str(i)][k] = {
- "index": f[f"{i}/{k}/index"][:, :, :v],
- "score": f[f"{i}/{k}/score"][:, :, :v],
- "query": f[f"{i}/{k}/query"][:]
- }
-
- knowledge_idx = {}
- for i in knowledge_idx_.keys():
- for j, id in enumerate(knowledge_idx_[i]["image_ids"]):
- knowledge_idx[id] = {}
- for k in topk.keys():
- knowledge_idx[id][k] = {
- "index": knowledge_idx_[i][k]["index"][j],
- "score": knowledge_idx_[i][k]["score"][j],
- "query": knowledge_idx_[i][k]["query"][j],
- }
-
- return knowledge_idx, fdim, file_hash
-
- def __getitem__(self, image_id):
- return self.knowledge_idx[image_id]
-
-
-class KnowAugImageCrops:
- def __init__(self, knowledge_db: TextDB, knowledge_idx: ImageCropsIdx, return_txt=False):
- self.knowledge_db = knowledge_db
- self.knowledge_idx = knowledge_idx
- assert knowledge_db.file_hash == knowledge_idx.file_hash
-
- self.ncrop = {"whole": 1, "five": 5, "nine": 9}
- self.topk = knowledge_idx.topk
- self.fdim = knowledge_idx.fdim
-
- self.return_txt = return_txt
-
- def __call__(self, image_id):
- ret = {}
- for k in self.topk.keys():
- ki = self.knowledge_idx[image_id][k]["index"].flatten()
- ke, kt = self.knowledge_db[ki]
- kq = self.knowledge_idx[image_id][k]["query"]
- kp = np.tile(np.arange(self.ncrop[k])[:, None], (1, self.topk[k])).flatten()
- ks = self.knowledge_idx[image_id][k]["score"].flatten()
-
- ke = torch.FloatTensor(ke)
- kq = torch.FloatTensor(kq)
- kp = torch.LongTensor(kp)
- ks = torch.FloatTensor(ks)
-
- ret[k] = {"embed": ke, "query": kq, "pos": kp, "score": ks}
- if self.return_txt:
- ret[k]["text"] = kt
-
- return ret
-
-
-class KnowAugImageCropsCombined:
- def __init__(
- self,
- knwl_aug_obj: KnowAugImageCrops,
- knwl_aug_attr: KnowAugImageCrops,
- knwl_aug_act: KnowAugImageCrops
- ):
- self.knwl_aug_obj = knwl_aug_obj
- self.knwl_aug_act = knwl_aug_act
- self.knwl_aug_attr = knwl_aug_attr
- self.fdim = knwl_aug_obj.fdim
-
- def __call__(self, image_id):
- knwl_obj = self.knwl_aug_obj(image_id)
- knwl_attr = self.knwl_aug_attr(image_id)
- knwl_act = self.knwl_aug_act(image_id)
-
- ret = {}
- for k in knwl_obj.keys():
- ret[k] = {
- "obj": knwl_obj[k],
- "attr": knwl_attr[k],
- "act": knwl_act[k]
- }
-
- return ret
diff --git a/spaces/Gen-Sim/Gen-Sim/cliport/models/streams/two_stream_transport_lang_fusion.py b/spaces/Gen-Sim/Gen-Sim/cliport/models/streams/two_stream_transport_lang_fusion.py
deleted file mode 100644
index b20a28c446071ed50dad3ce7977ae6c9b459fec3..0000000000000000000000000000000000000000
--- a/spaces/Gen-Sim/Gen-Sim/cliport/models/streams/two_stream_transport_lang_fusion.py
+++ /dev/null
@@ -1,196 +0,0 @@
-import torch
-import numpy as np
-
-import cliport.models as models
-import cliport.models.core.fusion as fusion
-from cliport.models.core.transport import Transport
-
-
-class TwoStreamTransportLangFusion(Transport):
- """Two Stream Transport (a.k.a Place) module"""
-
- def __init__(self, stream_fcn, in_shape, n_rotations, crop_size, preprocess, cfg, device):
- self.fusion_type = cfg['train']['trans_stream_fusion_type']
- super().__init__(stream_fcn, in_shape, n_rotations, crop_size, preprocess, cfg, device)
-
- def _build_nets(self):
- stream_one_fcn, stream_two_fcn = self.stream_fcn
- stream_one_model = models.names[stream_one_fcn]
- stream_two_model = models.names[stream_two_fcn]
-
- self.key_stream_one = stream_one_model(self.in_shape, self.output_dim, self.cfg, self.device, self.preprocess)
- self.key_stream_two = stream_two_model(self.in_shape, self.output_dim, self.cfg, self.device, self.preprocess)
- self.query_stream_one = stream_one_model(self.kernel_shape, self.kernel_dim, self.cfg, self.device, self.preprocess)
- self.query_stream_two = stream_two_model(self.kernel_shape, self.kernel_dim, self.cfg, self.device, self.preprocess)
- self.fusion_key = fusion.names[self.fusion_type](input_dim=self.kernel_dim)
- self.fusion_query = fusion.names[self.fusion_type](input_dim=self.kernel_dim)
-
- print(f"Transport FCN - Stream One: {stream_one_fcn}, Stream Two: {stream_two_fcn}, Stream Fusion: {self.fusion_type}")
-
- def transport2(self, in_tensor, crop, l):
- logits = self.fusion_key(self.key_stream_one(in_tensor), self.key_stream_two(in_tensor, l))
- kernel = self.fusion_query(self.query_stream_one(crop), self.query_stream_two(crop, l))
- return logits, kernel
-
- def forward(self, inp_img, p, lang_goal, softmax=True):
- """Forward pass."""
- if len(inp_img.shape) < 4:
- inp_img = inp_img[None]
-
- if type(inp_img) is not torch.Tensor:
- in_data = inp_img # .reshape(in_shape)
- in_tens = torch.from_numpy(in_data).to(dtype=torch.float, device=self.device) # [B W H 6]
- else:
- in_data = inp_img
- in_tens = in_data
-
- in_tensor = torch.nn.functional.pad(in_tens, tuple(self.padding[[2,1,0]].reshape(-1)), mode='constant')
- if type(p[0]) is not torch.Tensor:
- p = torch.FloatTensor(p)[None]
-
- in_tensors = []
- crops = []
-
- # this for loop is fast.
- for i in range(len(in_tensor)):
- in_tensor_i = in_tensor[[i]]
- # Rotation pivot.
- pv = p[i] + self.pad_size
-
- # Crop before network (default for Transporters CoRL 2020).
- hcrop = self.pad_size
- in_tensor_i = in_tensor_i.permute(0, 3, 1, 2)
-
- crop = [in_tensor_i] * self.n_rotations
- crop = self.rotator(crop, pivot=pv.float())
- crop = torch.cat(crop, dim=0)
- crop = crop[:, :, int(pv[0]-hcrop):int(pv[0]+hcrop), int(pv[1]-hcrop):int(pv[1]+hcrop)]
-
- in_tensors.append(in_tensor_i)
- crops.append(crop)
-
- logits, kernels = self.transport(torch.cat(in_tensors,dim=0), torch.cat(crops, dim=0), lang_goal) #crops.shape:(8, 36, 6, 64, 64)
- res = self.correlate(logits, kernels, softmax)
- return res
-
-class TwoStreamTransportLangFusionLat(TwoStreamTransportLangFusion):
- """Two Stream Transport (a.k.a Place) module with lateral connections"""
-
- def __init__(self, stream_fcn, in_shape, n_rotations, crop_size, preprocess, cfg, device):
-
- self.fusion_type = cfg['train']['trans_stream_fusion_type']
- super().__init__(stream_fcn, in_shape, n_rotations, crop_size, preprocess, cfg, device)
-
- def transport(self, in_tensor, crop, l):
- key_out_one, key_lat_one = self.key_stream_one(in_tensor)
- key_out_two = self.key_stream_two(in_tensor, key_lat_one, l)
- logits = self.fusion_key(key_out_one, key_out_two)
-
- query_out_one, query_lat_one = self.query_stream_one(crop)
- query_out_two = self.query_stream_two(crop, query_lat_one, l)
- kernel = self.fusion_query(query_out_one, query_out_two)
-
- return logits, kernel
-
-
-class TwoStreamTransportLangFusionLatReduce(TwoStreamTransportLangFusionLat):
- """Two Stream Transport (a.k.a Place) module with lateral connections"""
-
- def __init__(self, stream_fcn, in_shape, n_rotations, crop_size, preprocess, cfg, device):
-
- self.fusion_type = cfg['train']['trans_stream_fusion_type']
- super().__init__(stream_fcn, in_shape, n_rotations, crop_size, preprocess, cfg, device)
-
- del self.query_stream_one
- del self.query_stream_two
- # del self.key_stream_one
- # del self.key_stream_two
-
- stream_one_fcn = 'plain_resnet_reduce_lat'
- stream_one_model = models.names[stream_one_fcn]
- stream_two_fcn = 'clip_ling'
- stream_two_model = models.names[stream_two_fcn]
-
-
-
- # self.key_stream_one = stream_one_model(self.in_shape, self.output_dim, self.cfg, self.device, self.preprocess)
- # self.key_stream_two = stream_two_model(self.in_shape, self.output_dim, self.cfg, self.device, self.preprocess)
-
- self.query_stream_one = stream_one_model(self.kernel_shape, self.kernel_dim, self.cfg, self.device, self.preprocess)
- self.query_stream_two = stream_two_model(self.kernel_shape, self.kernel_dim, self.cfg, self.device, self.preprocess)
-
- def transport(self, in_tensor, crop, l):
- key_out_one, key_lat_one = self.key_stream_one(in_tensor)
- key_out_two = self.key_stream_two(in_tensor, key_lat_one, l)
- logits = self.fusion_key(key_out_one, key_out_two)
-
- query_out_one, query_lat_one = self.query_stream_one(crop)
- query_out_two = self.query_stream_two(crop, query_lat_one, l)
- kernel = self.fusion_query(query_out_one, query_out_two)
-
- return logits, kernel
-
-
-
-
-
-class TwoStreamTransportLangFusionLatReduceOneStream(TwoStreamTransportLangFusionLatReduce):
- """Two Stream Transport (a.k.a Place) module with lateral connections"""
-
- def __init__(self, stream_fcn, in_shape, n_rotations, crop_size, preprocess, cfg, device):
-
- self.fusion_type = cfg['train']['trans_stream_fusion_type']
- super().__init__(stream_fcn, in_shape, n_rotations, crop_size, preprocess, cfg, device)
-
- del self.query_stream_one
- del self.query_stream_two
-
-
-
- def transport(self, in_tensor, crop, l):
- key_out_one, key_lat_one = self.key_stream_one(in_tensor)
- key_out_two = self.key_stream_two(in_tensor, key_lat_one, l)
- logits = self.fusion_key(key_out_one, key_out_two)
-
- query_out_one, query_lat_one = self.key_stream_one(crop)
- query_out_two = self.key_stream_two(crop, query_lat_one, l)
- kernel = self.fusion_query(query_out_one, query_out_two)
-
- return logits, kernel
-
-
-
-
-class TwoStreamTransportLangFusionLatPretrained18(TwoStreamTransportLangFusionLat):
- """Two Stream Transport (a.k.a Place) module with lateral connections"""
-
- def __init__(self, stream_fcn, in_shape, n_rotations, crop_size, preprocess, cfg, device):
-
- self.fusion_type = cfg['train']['trans_stream_fusion_type']
- super().__init__(stream_fcn, in_shape, n_rotations, crop_size, preprocess, cfg, device)
-
- del self.query_stream_one
- del self.query_stream_two
- # del self.key_stream_one
- # del self.key_stream_two
- stream_one_fcn = 'pretrained_resnet18'
- stream_one_model = models.names[stream_one_fcn]
- stream_two_fcn = 'clip_ling'
- stream_two_model = models.names[stream_two_fcn]
-
- # self.key_stream_one = stream_one_model(self.in_shape, self.output_dim, self.cfg, self.device, self.preprocess)
- # self.key_stream_two = stream_two_model(self.in_shape, self.output_dim, self.cfg, self.device, self.preprocess)
-
- self.query_stream_one = stream_one_model(self.kernel_shape, self.kernel_dim, self.cfg, self.device, self.preprocess)
- self.query_stream_two = stream_two_model(self.kernel_shape, self.kernel_dim, self.cfg, self.device, self.preprocess)
-
- def transport(self, in_tensor, crop, l):
- key_out_one, key_lat_one = self.key_stream_one(in_tensor)
- key_out_two = self.key_stream_two(in_tensor, key_lat_one, l)
- logits = self.fusion_key(key_out_one, key_out_two)
-
- query_out_one, query_lat_one = self.query_stream_one(crop)
- query_out_two = self.query_stream_two(crop, query_lat_one, l)
- kernel = self.fusion_query(query_out_one, query_out_two)
-
- return logits, kernel
\ No newline at end of file
diff --git a/spaces/Gen-Sim/Gen-Sim/cliport/utils/__init__.py b/spaces/Gen-Sim/Gen-Sim/cliport/utils/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/GeorgeOrville/bingo/postcss.config.js b/spaces/GeorgeOrville/bingo/postcss.config.js
deleted file mode 100644
index 33ad091d26d8a9dc95ebdf616e217d985ec215b8..0000000000000000000000000000000000000000
--- a/spaces/GeorgeOrville/bingo/postcss.config.js
+++ /dev/null
@@ -1,6 +0,0 @@
-module.exports = {
- plugins: {
- tailwindcss: {},
- autoprefixer: {},
- },
-}
diff --git a/spaces/Gradio-Blocks/HairCLIP/model.py b/spaces/Gradio-Blocks/HairCLIP/model.py
deleted file mode 100644
index a16120b23a7a88c0c63fd9c74fe89fa8867b16eb..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/HairCLIP/model.py
+++ /dev/null
@@ -1,160 +0,0 @@
-from __future__ import annotations
-
-import argparse
-import os
-import pathlib
-import subprocess
-import sys
-from typing import Callable, Union
-
-import dlib
-import huggingface_hub
-import numpy as np
-import PIL.Image
-import torch
-import torch.nn as nn
-import torchvision.transforms as T
-
-if os.getenv('SYSTEM') == 'spaces' and not torch.cuda.is_available():
- with open('patch.e4e') as f:
- subprocess.run('patch -p1'.split(), cwd='encoder4editing', stdin=f)
- with open('patch.hairclip') as f:
- subprocess.run('patch -p1'.split(), cwd='HairCLIP', stdin=f)
-
-app_dir = pathlib.Path(__file__).parent
-
-e4e_dir = app_dir / 'encoder4editing'
-sys.path.insert(0, e4e_dir.as_posix())
-
-from models.psp import pSp
-from utils.alignment import align_face
-
-hairclip_dir = app_dir / 'HairCLIP'
-mapper_dir = hairclip_dir / 'mapper'
-sys.path.insert(0, hairclip_dir.as_posix())
-sys.path.insert(0, mapper_dir.as_posix())
-
-from mapper.datasets.latents_dataset_inference import LatentsDatasetInference
-from mapper.hairclip_mapper import HairCLIPMapper
-
-
-class Model:
- def __init__(self):
- self.device = torch.device(
- 'cuda:0' if torch.cuda.is_available() else 'cpu')
- self.landmark_model = self._create_dlib_landmark_model()
- self.e4e = self._load_e4e()
- self.hairclip = self._load_hairclip()
- self.transform = self._create_transform()
-
- @staticmethod
- def _create_dlib_landmark_model():
- path = huggingface_hub.hf_hub_download(
- 'public-data/dlib_face_landmark_model',
- 'shape_predictor_68_face_landmarks.dat')
- return dlib.shape_predictor(path)
-
- def _load_e4e(self) -> nn.Module:
- ckpt_path = huggingface_hub.hf_hub_download('public-data/e4e',
- 'e4e_ffhq_encode.pt')
- ckpt = torch.load(ckpt_path, map_location='cpu')
- opts = ckpt['opts']
- opts['device'] = self.device.type
- opts['checkpoint_path'] = ckpt_path
- opts = argparse.Namespace(**opts)
- model = pSp(opts)
- model.to(self.device)
- model.eval()
- return model
-
- def _load_hairclip(self) -> nn.Module:
- ckpt_path = huggingface_hub.hf_hub_download('public-data/HairCLIP',
- 'hairclip.pt')
- ckpt = torch.load(ckpt_path, map_location='cpu')
- opts = ckpt['opts']
- opts['device'] = self.device.type
- opts['checkpoint_path'] = ckpt_path
- opts['editing_type'] = 'both'
- opts['input_type'] = 'text'
- opts['hairstyle_description'] = 'HairCLIP/mapper/hairstyle_list.txt'
- opts['color_description'] = 'red'
- opts = argparse.Namespace(**opts)
- model = HairCLIPMapper(opts)
- model.to(self.device)
- model.eval()
- return model
-
- @staticmethod
- def _create_transform() -> Callable:
- transform = T.Compose([
- T.Resize(256),
- T.CenterCrop(256),
- T.ToTensor(),
- T.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]),
- ])
- return transform
-
- def detect_and_align_face(self, image: str) -> PIL.Image.Image:
- image = align_face(filepath=image, predictor=self.landmark_model)
- return image
-
- @staticmethod
- def denormalize(tensor: torch.Tensor) -> torch.Tensor:
- return torch.clamp((tensor + 1) / 2 * 255, 0, 255).to(torch.uint8)
-
- def postprocess(self, tensor: torch.Tensor) -> np.ndarray:
- tensor = self.denormalize(tensor)
- return tensor.cpu().numpy().transpose(1, 2, 0)
-
- @torch.inference_mode()
- def reconstruct_face(
- self, image: PIL.Image.Image) -> tuple[np.ndarray, torch.Tensor]:
- input_data = self.transform(image).unsqueeze(0).to(self.device)
- reconstructed_images, latents = self.e4e(input_data,
- randomize_noise=False,
- return_latents=True)
- reconstructed = torch.clamp(reconstructed_images[0].detach(), -1, 1)
- reconstructed = self.postprocess(reconstructed)
- return reconstructed, latents[0]
-
- @torch.inference_mode()
- def generate(self, editing_type: str, hairstyle_index: int,
- color_description: str, latent: torch.Tensor) -> np.ndarray:
- opts = self.hairclip.opts
- opts.editing_type = editing_type
- opts.color_description = color_description
-
- if editing_type == 'color':
- hairstyle_index = 0
-
- device = torch.device(opts.device)
-
- dataset = LatentsDatasetInference(latents=latent.unsqueeze(0).cpu(),
- opts=opts)
- w, hairstyle_text_inputs_list, color_text_inputs_list = dataset[0][:3]
-
- w = w.unsqueeze(0).to(device)
- hairstyle_text_inputs = hairstyle_text_inputs_list[
- hairstyle_index].unsqueeze(0).to(device)
- color_text_inputs = color_text_inputs_list[0].unsqueeze(0).to(device)
-
- hairstyle_tensor_hairmasked = torch.Tensor([0]).unsqueeze(0).to(device)
- color_tensor_hairmasked = torch.Tensor([0]).unsqueeze(0).to(device)
-
- w_hat = w + 0.1 * self.hairclip.mapper(
- w,
- hairstyle_text_inputs,
- color_text_inputs,
- hairstyle_tensor_hairmasked,
- color_tensor_hairmasked,
- )
- x_hat, _ = self.hairclip.decoder(
- [w_hat],
- input_is_latent=True,
- return_latents=True,
- randomize_noise=False,
- truncation=1,
- )
- res = torch.clamp(x_hat[0].detach(), -1, 1)
- res = self.postprocess(res)
- return res
diff --git a/spaces/Gradio-Blocks/Story_and_Video_Generation/README.md b/spaces/Gradio-Blocks/Story_and_Video_Generation/README.md
deleted file mode 100644
index 5f7e90e9f81574e342ac4af6100d154a1ac807d9..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/Story_and_Video_Generation/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Story_and_Video_Generation
-emoji: 📖🎬
-colorFrom: blue
-colorTo: pink
-sdk: gradio
-sdk_version: 3.0.2
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference
diff --git a/spaces/Gradio-Blocks/uniformer_image_detection/mmdet/models/backbones/resnest.py b/spaces/Gradio-Blocks/uniformer_image_detection/mmdet/models/backbones/resnest.py
deleted file mode 100644
index 48e1d8bfa47348a13f0da0b9ecf32354fa270340..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_detection/mmdet/models/backbones/resnest.py
+++ /dev/null
@@ -1,317 +0,0 @@
-import math
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.utils.checkpoint as cp
-from mmcv.cnn import build_conv_layer, build_norm_layer
-
-from ..builder import BACKBONES
-from ..utils import ResLayer
-from .resnet import Bottleneck as _Bottleneck
-from .resnet import ResNetV1d
-
-
-class RSoftmax(nn.Module):
- """Radix Softmax module in ``SplitAttentionConv2d``.
-
- Args:
- radix (int): Radix of input.
- groups (int): Groups of input.
- """
-
- def __init__(self, radix, groups):
- super().__init__()
- self.radix = radix
- self.groups = groups
-
- def forward(self, x):
- batch = x.size(0)
- if self.radix > 1:
- x = x.view(batch, self.groups, self.radix, -1).transpose(1, 2)
- x = F.softmax(x, dim=1)
- x = x.reshape(batch, -1)
- else:
- x = torch.sigmoid(x)
- return x
-
-
-class SplitAttentionConv2d(nn.Module):
- """Split-Attention Conv2d in ResNeSt.
-
- Args:
- in_channels (int): Number of channels in the input feature map.
- channels (int): Number of intermediate channels.
- kernel_size (int | tuple[int]): Size of the convolution kernel.
- stride (int | tuple[int]): Stride of the convolution.
- padding (int | tuple[int]): Zero-padding added to both sides of
- dilation (int | tuple[int]): Spacing between kernel elements.
- groups (int): Number of blocked connections from input channels to
- output channels.
- groups (int): Same as nn.Conv2d.
- radix (int): Radix of SpltAtConv2d. Default: 2
- reduction_factor (int): Reduction factor of inter_channels. Default: 4.
- conv_cfg (dict): Config dict for convolution layer. Default: None,
- which means using conv2d.
- norm_cfg (dict): Config dict for normalization layer. Default: None.
- dcn (dict): Config dict for DCN. Default: None.
- """
-
- def __init__(self,
- in_channels,
- channels,
- kernel_size,
- stride=1,
- padding=0,
- dilation=1,
- groups=1,
- radix=2,
- reduction_factor=4,
- conv_cfg=None,
- norm_cfg=dict(type='BN'),
- dcn=None):
- super(SplitAttentionConv2d, self).__init__()
- inter_channels = max(in_channels * radix // reduction_factor, 32)
- self.radix = radix
- self.groups = groups
- self.channels = channels
- self.with_dcn = dcn is not None
- self.dcn = dcn
- fallback_on_stride = False
- if self.with_dcn:
- fallback_on_stride = self.dcn.pop('fallback_on_stride', False)
- if self.with_dcn and not fallback_on_stride:
- assert conv_cfg is None, 'conv_cfg must be None for DCN'
- conv_cfg = dcn
- self.conv = build_conv_layer(
- conv_cfg,
- in_channels,
- channels * radix,
- kernel_size,
- stride=stride,
- padding=padding,
- dilation=dilation,
- groups=groups * radix,
- bias=False)
- # To be consistent with original implementation, starting from 0
- self.norm0_name, norm0 = build_norm_layer(
- norm_cfg, channels * radix, postfix=0)
- self.add_module(self.norm0_name, norm0)
- self.relu = nn.ReLU(inplace=True)
- self.fc1 = build_conv_layer(
- None, channels, inter_channels, 1, groups=self.groups)
- self.norm1_name, norm1 = build_norm_layer(
- norm_cfg, inter_channels, postfix=1)
- self.add_module(self.norm1_name, norm1)
- self.fc2 = build_conv_layer(
- None, inter_channels, channels * radix, 1, groups=self.groups)
- self.rsoftmax = RSoftmax(radix, groups)
-
- @property
- def norm0(self):
- """nn.Module: the normalization layer named "norm0" """
- return getattr(self, self.norm0_name)
-
- @property
- def norm1(self):
- """nn.Module: the normalization layer named "norm1" """
- return getattr(self, self.norm1_name)
-
- def forward(self, x):
- x = self.conv(x)
- x = self.norm0(x)
- x = self.relu(x)
-
- batch, rchannel = x.shape[:2]
- batch = x.size(0)
- if self.radix > 1:
- splits = x.view(batch, self.radix, -1, *x.shape[2:])
- gap = splits.sum(dim=1)
- else:
- gap = x
- gap = F.adaptive_avg_pool2d(gap, 1)
- gap = self.fc1(gap)
-
- gap = self.norm1(gap)
- gap = self.relu(gap)
-
- atten = self.fc2(gap)
- atten = self.rsoftmax(atten).view(batch, -1, 1, 1)
-
- if self.radix > 1:
- attens = atten.view(batch, self.radix, -1, *atten.shape[2:])
- out = torch.sum(attens * splits, dim=1)
- else:
- out = atten * x
- return out.contiguous()
-
-
-class Bottleneck(_Bottleneck):
- """Bottleneck block for ResNeSt.
-
- Args:
- inplane (int): Input planes of this block.
- planes (int): Middle planes of this block.
- groups (int): Groups of conv2.
- base_width (int): Base of width in terms of base channels. Default: 4.
- base_channels (int): Base of channels for calculating width.
- Default: 64.
- radix (int): Radix of SpltAtConv2d. Default: 2
- reduction_factor (int): Reduction factor of inter_channels in
- SplitAttentionConv2d. Default: 4.
- avg_down_stride (bool): Whether to use average pool for stride in
- Bottleneck. Default: True.
- kwargs (dict): Key word arguments for base class.
- """
- expansion = 4
-
- def __init__(self,
- inplanes,
- planes,
- groups=1,
- base_width=4,
- base_channels=64,
- radix=2,
- reduction_factor=4,
- avg_down_stride=True,
- **kwargs):
- """Bottleneck block for ResNeSt."""
- super(Bottleneck, self).__init__(inplanes, planes, **kwargs)
-
- if groups == 1:
- width = self.planes
- else:
- width = math.floor(self.planes *
- (base_width / base_channels)) * groups
-
- self.avg_down_stride = avg_down_stride and self.conv2_stride > 1
-
- self.norm1_name, norm1 = build_norm_layer(
- self.norm_cfg, width, postfix=1)
- self.norm3_name, norm3 = build_norm_layer(
- self.norm_cfg, self.planes * self.expansion, postfix=3)
-
- self.conv1 = build_conv_layer(
- self.conv_cfg,
- self.inplanes,
- width,
- kernel_size=1,
- stride=self.conv1_stride,
- bias=False)
- self.add_module(self.norm1_name, norm1)
- self.with_modulated_dcn = False
- self.conv2 = SplitAttentionConv2d(
- width,
- width,
- kernel_size=3,
- stride=1 if self.avg_down_stride else self.conv2_stride,
- padding=self.dilation,
- dilation=self.dilation,
- groups=groups,
- radix=radix,
- reduction_factor=reduction_factor,
- conv_cfg=self.conv_cfg,
- norm_cfg=self.norm_cfg,
- dcn=self.dcn)
- delattr(self, self.norm2_name)
-
- if self.avg_down_stride:
- self.avd_layer = nn.AvgPool2d(3, self.conv2_stride, padding=1)
-
- self.conv3 = build_conv_layer(
- self.conv_cfg,
- width,
- self.planes * self.expansion,
- kernel_size=1,
- bias=False)
- self.add_module(self.norm3_name, norm3)
-
- def forward(self, x):
-
- def _inner_forward(x):
- identity = x
-
- out = self.conv1(x)
- out = self.norm1(out)
- out = self.relu(out)
-
- if self.with_plugins:
- out = self.forward_plugin(out, self.after_conv1_plugin_names)
-
- out = self.conv2(out)
-
- if self.avg_down_stride:
- out = self.avd_layer(out)
-
- if self.with_plugins:
- out = self.forward_plugin(out, self.after_conv2_plugin_names)
-
- out = self.conv3(out)
- out = self.norm3(out)
-
- if self.with_plugins:
- out = self.forward_plugin(out, self.after_conv3_plugin_names)
-
- if self.downsample is not None:
- identity = self.downsample(x)
-
- out += identity
-
- return out
-
- if self.with_cp and x.requires_grad:
- out = cp.checkpoint(_inner_forward, x)
- else:
- out = _inner_forward(x)
-
- out = self.relu(out)
-
- return out
-
-
-@BACKBONES.register_module()
-class ResNeSt(ResNetV1d):
- """ResNeSt backbone.
-
- Args:
- groups (int): Number of groups of Bottleneck. Default: 1
- base_width (int): Base width of Bottleneck. Default: 4
- radix (int): Radix of SplitAttentionConv2d. Default: 2
- reduction_factor (int): Reduction factor of inter_channels in
- SplitAttentionConv2d. Default: 4.
- avg_down_stride (bool): Whether to use average pool for stride in
- Bottleneck. Default: True.
- kwargs (dict): Keyword arguments for ResNet.
- """
-
- arch_settings = {
- 50: (Bottleneck, (3, 4, 6, 3)),
- 101: (Bottleneck, (3, 4, 23, 3)),
- 152: (Bottleneck, (3, 8, 36, 3)),
- 200: (Bottleneck, (3, 24, 36, 3))
- }
-
- def __init__(self,
- groups=1,
- base_width=4,
- radix=2,
- reduction_factor=4,
- avg_down_stride=True,
- **kwargs):
- self.groups = groups
- self.base_width = base_width
- self.radix = radix
- self.reduction_factor = reduction_factor
- self.avg_down_stride = avg_down_stride
- super(ResNeSt, self).__init__(**kwargs)
-
- def make_res_layer(self, **kwargs):
- """Pack all blocks in a stage into a ``ResLayer``."""
- return ResLayer(
- groups=self.groups,
- base_width=self.base_width,
- base_channels=self.base_channels,
- radix=self.radix,
- reduction_factor=self.reduction_factor,
- avg_down_stride=self.avg_down_stride,
- **kwargs)
diff --git a/spaces/HaHaBill/LandShapes-Antarctica/netdissect/server.py b/spaces/HaHaBill/LandShapes-Antarctica/netdissect/server.py
deleted file mode 100644
index d8422a2bad5ac2a09d4582a98da4f962dac1a911..0000000000000000000000000000000000000000
--- a/spaces/HaHaBill/LandShapes-Antarctica/netdissect/server.py
+++ /dev/null
@@ -1,185 +0,0 @@
-#!/usr/bin/env python
-
-import argparse, connexion, os, sys, yaml, json, socket
-from netdissect.easydict import EasyDict
-from flask import send_from_directory, redirect
-from flask_cors import CORS
-
-
-from netdissect.serverstate import DissectionProject
-
-__author__ = 'Hendrik Strobelt, David Bau'
-
-CONFIG_FILE_NAME = 'dissect.json'
-projects = {}
-
-app = connexion.App(__name__, debug=False)
-
-
-def get_all_projects():
- res = []
- for key, project in projects.items():
- # print key
- res.append({
- 'project': key,
- 'info': {
- 'layers': [layer['layer'] for layer in project.get_layers()]
- }
- })
- return sorted(res, key=lambda x: x['project'])
-
-def get_layers(project):
- return {
- 'request': {'project': project},
- 'res': projects[project].get_layers()
- }
-
-def get_units(project, layer):
- return {
- 'request': {'project': project, 'layer': layer},
- 'res': projects[project].get_units(layer)
- }
-
-def get_rankings(project, layer):
- return {
- 'request': {'project': project, 'layer': layer},
- 'res': projects[project].get_rankings(layer)
- }
-
-def get_levels(project, layer, quantiles):
- return {
- 'request': {'project': project, 'layer': layer, 'quantiles': quantiles},
- 'res': projects[project].get_levels(layer, quantiles)
- }
-
-def get_channels(project, layer):
- answer = dict(channels=projects[project].get_channels(layer))
- return {
- 'request': {'project': project, 'layer': layer},
- 'res': answer
- }
-
-def post_generate(gen_req):
- project = gen_req['project']
- zs = gen_req.get('zs', None)
- ids = gen_req.get('ids', None)
- return_urls = gen_req.get('return_urls', False)
- assert (zs is None) != (ids is None) # one or the other, not both
- ablations = gen_req.get('ablations', [])
- interventions = gen_req.get('interventions', None)
- # no z avilable if ablations
- generated = projects[project].generate_images(zs, ids, interventions,
- return_urls=return_urls)
- return {
- 'request': gen_req,
- 'res': generated
- }
-
-def post_features(feat_req):
- project = feat_req['project']
- ids = feat_req['ids']
- masks = feat_req.get('masks', None)
- layers = feat_req.get('layers', None)
- interventions = feat_req.get('interventions', None)
- features = projects[project].get_features(
- ids, masks, layers, interventions)
- return {
- 'request': feat_req,
- 'res': features
- }
-
-def post_featuremaps(feat_req):
- project = feat_req['project']
- ids = feat_req['ids']
- layers = feat_req.get('layers', None)
- interventions = feat_req.get('interventions', None)
- featuremaps = projects[project].get_featuremaps(
- ids, layers, interventions)
- return {
- 'request': feat_req,
- 'res': featuremaps
- }
-
-@app.route('/client/
-
- ArtIstic GENREator
-Generate Inspirational Lyrics and Single Cover
-
GPT Akademisch optimiert (GPT Academic)
-
-**Wenn Ihnen dieses Projekt gefällt, geben Sie ihm bitte einen Stern; wenn Sie bessere Tastenkombinationen oder Funktions-Plugins entwickelt haben, können Sie gerne einen Pull Request eröffnen.**
-
-Wenn Sie dieses Projekt mögen, geben Sie ihm bitte einen Stern. Wenn Sie weitere nützliche wissenschaftliche Abkürzungen oder funktionale Plugins entwickelt haben, können Sie gerne ein Problem oder eine Pull-Anforderung öffnen. Wir haben auch ein README in [Englisch|](docs/README_EN.md)[日本語|](docs/README_JP.md)[한국어|](https://github.com/mldljyh/ko_gpt_academic)[Русский|](docs/README_RS.md)[Français](docs/README_FR.md), das von diesem Projekt selbst übersetzt wurde.
-Um dieses Projekt in eine beliebige Sprache mit GPT zu übersetzen, lesen Sie `multi_language.py` (experimentell).
-
-> **Hinweis**
->
-> 1. Beachten Sie bitte, dass nur Funktionserweiterungen (Schaltflächen) mit **roter Farbe** Dateien lesen können und einige Erweiterungen im **Dropdown-Menü** des Erweiterungsbereichs zu finden sind. Außerdem begrüßen wir jede neue Funktionserweiterung mit **höchster Priorität** und bearbeiten sie.
->
-> 2. Die Funktionalität jeder Datei in diesem Projekt wird in der Selbstanalyse [`self_analysis.md`](https://github.com/binary-husky/gpt_academic/wiki/chatgpt-academic%E9%A1%B9%E7%9B%AE%E8%87%AA%E8%AF%91%E8%A7%A3%E6%8A%A5%E5%91%8A) detailliert beschrieben. Mit der Weiterentwicklung der Versionen können Sie jederzeit die zugehörigen Funktions-Erweiterungen aufrufen, um durch Aufruf von GPT einen Selbstanalysebericht des Projekts zu erstellen. Häufig gestellte Fragen finden Sie in der [`Wiki`](https://github.com/binary-husky/gpt_academic/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98). [Installationsanweisungen](#Installation).
->
-> 3. Dieses Projekt ist kompatibel und fördert die Verwendung von inländischen Sprachmodellen wie ChatGLM und RWKV, Pangu, etc. Es unterstützt das Vorhandensein mehrerer api-keys, die in der Konfigurationsdatei wie folgt angegeben werden können: `API_KEY="openai-key1,openai-key2,api2d-key3"`. Wenn ein `API_KEY` temporär geändert werden muss, geben Sie den temporären `API_KEY` im Eingabebereich ein und drücken Sie dann die Eingabetaste, um ihn zu übernehmen.Funktion | Beschreibung
---- | ---
-Ein-Klick-Polieren | Unterstützt ein-Klick-Polieren und ein-Klick-Suche nach grammatikalischen Fehlern in wissenschaftlichen Arbeiten
-Ein-Klick Chinesisch-Englisch Übersetzung | Ein-Klick Chinesisch-Englisch Übersetzung
-Ein-Klick-Code-Erklärung | Zeigt Code, erklärt Code, erzeugt Code und fügt Kommentare zum Code hinzu
-[Benutzerdefinierte Tastenkombinationen](https://www.bilibili.com/video/BV14s4y1E7jN) | Unterstützt benutzerdefinierte Tastenkombinationen
-Modulare Gestaltung | Unterstützt leistungsstarke individuelle [Funktions-Plugins](https://github.com/binary-husky/gpt_academic/tree/master/crazy_functions). Plugins unterstützen [Hot-Updates](https://github.com/binary-husky/gpt_academic/wiki/%E5%87%BD%E6%95%B0%E6%8F%92%E4%BB%B6%E6%8C%87%E5%8D%97)
-[Selbstprogramm-Analyse](https://www.bilibili.com/video/BV1cj411A7VW) | [Funktions-Plugin] [Ein-Klick Verstehen](https://github.com/binary-husky/gpt_academic/wiki/chatgpt-academic%E9%A1%B9%E7%9B%AE%E8%87%AA%E8%AF%91%E8%A7%A3%E6%8A%A5%E5%91%8A) der Quellcode dieses Projekts
-[Programmanalyse](https://www.bilibili.com/video/BV1cj411A7VW) | [Funktions-Plugin] Ein-Klick-Analyse des Projektbaums anderer Python/C/C++/Java/Lua/...-Projekte
-Lesen von Papieren, [Übersetzen](https://www.bilibili.com/video/BV1KT411x7Wn) von Papieren | [Funktions-Plugin] Ein-Klick Erklärung des gesamten LaTeX/PDF-Artikels und Erstellung einer Zusammenfassung
-LaTeX-Volltext-Übersetzung und [Polieren](https://www.bilibili.com/video/BV1FT411H7c5/) | [Funktions-Plugin] Ein-Klick-Übersetzung oder-Polieren des LaTeX-Artikels
-Bulk-Kommentargenerierung | [Funktions-Plugin] Ein-Klick Massenerstellung von Funktionskommentaren
-Markdown [Chinesisch-Englisch Übersetzung](https://www.bilibili.com/video/BV1yo4y157jV/) | [Funktions-Plugin] Haben Sie die [README](https://github.com/binary-husky/gpt_academic/blob/master/docs/README_EN.md) in den oben genannten 5 Sprachen gesehen?
-Analyse-Berichtserstellung von chat | [Funktions-Plugin] Automatische Zusammenfassung nach der Ausführung
-[Funktion zur vollständigen Übersetzung von PDF-Artikeln](https://www.bilibili.com/video/BV1KT411x7Wn) | [Funktions-Plugin] Extrahiert Titel und Zusammenfassung der PDF-Artikel und übersetzt den gesamten Text (mehrere Threads)
-[Arxiv-Assistent](https://www.bilibili.com/video/BV1LM4y1279X) | [Funktions-Plugin] Geben Sie die Arxiv-Artikel-URL ein und klicken Sie auf Eine-Klick-Übersetzung-Zusammenfassung + PDF-Download
-[Google Scholar Integrations-Assistent](https://www.bilibili.com/video/BV19L411U7ia) | [Funktions-Plugin] Geben Sie eine beliebige Google Scholar Such-URL ein und lassen Sie gpt Ihnen bei der Erstellung von [relatedworks](https://www.bilibili.com/video/BV1GP411U7Az/) helfen
-Internet-Informationen Aggregation + GPT | [Funktions-Plugin] Lassen Sie GPT eine Frage beantworten, indem es [zuerst Informationen aus dem Internet](https://www.bilibili.com/video/BV1om4y127ck/) sammelt und so die Informationen nie veralten
-Anzeige von Formeln / Bildern / Tabellen | Zeigt Formeln in beiden Formen, [TeX-Format und gerendeter Form](https://user-images.githubusercontent.com/96192199/230598842-1d7fcddd-815d-40ee-af60-baf488a199df.png), unterstützt Formeln und Code-Highlights
-Unterstützung von PlugIns mit mehreren Threads | Unterstützt den Aufruf mehrerer Threads in Chatgpt, um Text oder Programme [Batch zu verarbeiten](https://www.bilibili.com/video/BV1FT411H7c5/)
-Starten Sie das dunkle Gradio-[Thema](https://github.com/binary-husky/gpt_academic/issues/173) | Fügen Sie ```/?__theme=dark``` an das Ende der Browser-URL an, um das dunkle Thema zu aktivieren
-[Unterstützung für mehrere LLM-Modelle](https://www.bilibili.com/video/BV1wT411p7yf), [API2D](https://api2d.com/) Interface-Unterstützung | Das Gefühl, gleichzeitig von GPT3.5, GPT4, [Tshinghua ChatGLM](https://github.com/THUDM/ChatGLM-6B), [Fudan MOSS](https://github.com/OpenLMLab/MOSS) bedient zu werden, muss toll sein, oder?
-Zugriff auf weitere LLM-Modelle, Unterstützung von [huggingface deployment](https://huggingface.co/spaces/qingxu98/gpt-academic) | Hinzufügen der Newbing-Schnittstelle (neues Bing), Einführung der Unterstützung von [Jittorllms](https://github.com/Jittor/JittorLLMs) der Tsinghua-Universität, [LLaMA](https://github.com/facebookresearch/llama), [RWKV](https://github.com/BlinkDL/ChatRWKV) und [Pangu alpha](https://openi.org.cn/pangu/)
-Weitere neue Funktionen (wie Bildgenerierung) …… | Siehe Ende dieses Dokuments ……
-
-- Neue Oberfläche (Ändern Sie die LAYOUT-Option in `config.py`, um zwischen "Seitenlayout" und "Oben-unten-Layout" zu wechseln)
-
-
-
- All buttons are dynamically generated by reading `functional.py`, and custom functions can be easily added, freeing up the clipboard.
-
-
-
-
-
-- Proofreading/Correcting
-
-
-
-
-
-- If the output contains formulas, they will be displayed in both tex format and rendered format for easy copying and reading.
-
-
-
-
-
-- Don't feel like reading the project code? Show off the entire project to chatgpt.
-
-
-
-
-
-- Multiple large language models are mixed and called together (ChatGLM + OpenAI-GPT3.5 + [API2D](https://api2d.com/)-GPT4).
-
-
-
-
-
----
-# Installation
-## Installation-Method 1: Run directly (Windows, Linux or MacOS)
-
-1. Download the project
-```sh
-git clone https://github.com/binary-husky/gpt_academic.git
-cd gpt_academic
-```
-
-2. Configure API_KEY
-
-Configure API KEY and other settings in `config.py`. [Special Network Environment Settings](https://github.com/binary-husky/gpt_academic/issues/1).
-
-(P.S. When the program is running, it will first check whether there is a "config_private.py" private configuration file, and use the configuration defined in it to override the configuration of "config.py". Therefore, if you understand our configuration reading logic, we strongly recommend that you create a new configuration file named "config_private.py" next to "config.py" and transfer (copy) the configurations in "config.py" to "config_private.py". "config_private.py" is not controlled by git, which can make your privacy information more secure. P.S. The project also supports configuring most options through `environment variables`, and the writing format of environment variables refers to the `docker-compose` file. Reading priority: `environment variable` > `config_private.py` >`config.py`)
-
-
-3. Install dependencies
-```sh
-# (Option I: If familar with Python) (Python version 3.9 or above, the newer the better), Note: Use the official pip source or Ali pip source, temporary switching method: python -m pip install -r requirements.txt -i https://mirrors.aliyun.com/pypi/simple/
-python -m pip install -r requirements.txt
-
-# (Option II: If not familiar with Python) Use anaconda with similar steps (https://www.bilibili.com/video/BV1rc411W7Dr):
-conda create -n gptac_venv python=3.11 # Create an anaconda environment
-conda activate gptac_venv # Activate the anaconda environment
-python -m pip install -r requirements.txt # Same step as pip installation
-```
-
-
-Click to expand if supporting Tsinghua ChatGLM/Fudan MOSS as backend
-- -[Optional Step] If supporting Tsinghua ChatGLM/Fudan MOSS as backend, additional dependencies need to be installed (Prerequisites: Familiar with Python + Used Pytorch + Sufficient computer configuration): -```sh -# [Optional Step I] Support Tsinghua ChatGLM. Remark: If encountering "Call ChatGLM fail Cannot load ChatGLM parameters", please refer to the following: 1: The above default installation is torch+cpu version. To use cuda, uninstall torch and reinstall torch+cuda; 2: If the model cannot be loaded due to insufficient machine configuration, you can modify the model precision in `request_llm/bridge_chatglm.py`, and modify all AutoTokenizer.from_pretrained("THUDM/chatglm-6b", trust_remote_code=True) to AutoTokenizer.from_pretrained("THUDM/chatglm-6b-int4", trust_remote_code=True) -python -m pip install -r request_llm/requirements_chatglm.txt - -# [Optional Step II] Support Fudan MOSS -python -m pip install -r request_llm/requirements_moss.txt -git clone https://github.com/OpenLMLab/MOSS.git request_llm/moss # When executing this line of code, you must be in the project root path - -# [Optional Step III] Make sure the AVAIL_LLM_MODELS in the config.py configuration file contains the expected models. Currently supported models are as follows (jittorllms series currently only supports docker solutions): -AVAIL_LLM_MODELS = ["gpt-3.5-turbo", "api2d-gpt-3.5-turbo", "gpt-4", "api2d-gpt-4", "chatglm", "newbing", "moss"] # + ["jittorllms_rwkv", "jittorllms_pangualpha", "jittorllms_llama"] -``` - -
-
-
-
-
-2. Custom function plugins
-
-Write powerful function plugins to perform any task you want and can't think of.
-The difficulty of plugin writing and debugging is very low in this project. As long as you have a certain knowledge of Python, you can implement your own plugin functions by imitating the template we provided.
-For more information, please refer to the [Function Plugin Guide](https://github.com/binary-husky/gpt_academic/wiki/%E5%87%BD%E6%95%B0%E6%8F%92%E4%BB%B6%E6%8C%87%E5%8D%97).
-
----
-# Latest Update
-## New feature dynamics1. Funktion zur Speicherung von Dialogen. Rufen Sie im Bereich der Funktions-Plugins "Aktuellen Dialog speichern" auf, um den aktuellen Dialog als lesbares und wiederherstellbares HTML-Datei zu speichern. Darüber hinaus können Sie im Funktions-Plugin-Bereich (Dropdown-Menü) "Laden von Dialogverlauf" aufrufen, um den vorherigen Dialog wiederherzustellen. Tipp: Wenn Sie keine Datei angeben und stattdessen direkt auf "Laden des Dialogverlaufs" klicken, können Sie das HTML-Cache-Archiv anzeigen. Durch Klicken auf "Löschen aller lokalen Dialogverlaufsdatensätze" können alle HTML-Archiv-Caches gelöscht werden.
-
-
-
-
-
-2. Berichterstellung. Die meisten Plugins generieren nach Abschluss der Ausführung einen Arbeitsbericht.
-
-
-
-
-
-
-
-3. Modularisierte Funktionsgestaltung, einfache Schnittstellen mit leistungsstarken Funktionen.
-
-
-
-
-
-
-
-
-4. Dies ist ein Open-Source-Projekt, das sich "selbst übersetzen" kann.
-
-
-
-
-
-
-5. Die Übersetzung anderer Open-Source-Projekte ist kein Problem.
-
-
-
-
-
-
-
-
-
-
-6. Dekorieren Sie [`live2d`](https://github.com/fghrsh/live2d_demo) mit kleinen Funktionen (standardmäßig deaktiviert, Änderungen an `config.py` erforderlich).
-
-
-
-
-
-7. Neue MOSS-Sprachmodellunterstützung.
-
-
-
-
-
-8. OpenAI-Bildgenerierung.
-
-
-
-
-
-9. OpenAI-Audio-Analyse und Zusammenfassung.
-
-
-
-
-10. Latex-Proofreading des gesamten Textes.
-
-
-
-
-
-## Version:
-- Version 3.5 (Todo): Rufen Sie alle Funktionserweiterungen dieses Projekts mit natürlicher Sprache auf (hohe Priorität).
-- Version 3.4 (Todo): Verbesserte Unterstützung mehrerer Threads für Local Large Model (LLM).
-- Version 3.3: + Internet-Informationssynthese-Funktion
-- Version 3.2: Funktionserweiterungen unterstützen mehr Parameter-Schnittstellen (Speicherung von Dialogen, Interpretation beliebigen Sprachcodes + gleichzeitige Abfrage jeder LLM-Kombination)
-- Version 3.1: Unterstützung mehrerer GPT-Modelle gleichzeitig! Unterstützung für API2D, Unterstützung für Lastenausgleich von mehreren API-Schlüsseln.
-- Version 3.0: Unterstützung von Chatglm und anderen kleinen LLMs
-- Version 2.6: Umstrukturierung der Plugin-Struktur zur Verbesserung der Interaktivität, Einführung weiterer Plugins
-- Version 2.5: Automatische Aktualisierung, Problembehebung bei Quelltexten großer Projekte, wenn der Text zu lang ist oder Token überlaufen.
-- Version 2.4: (1) Neue Funktion zur Übersetzung des gesamten PDF-Texts; (2) Neue Funktion zum Wechseln der Position des Eingabebereichs; (3) Neue Option für vertikales Layout; (4) Optimierung von Multithread-Funktions-Plugins.
-- Version 2.3: Verbesserte Interaktivität mit mehreren Threads
-- Version 2.2: Funktionserweiterungen unterstützen "Hot-Reload"
-- Version 2.1: Faltbares Layout
-- Version 2.0: Einführung von modularisierten Funktionserweiterungen
-- Version 1.0: Grundlegende Funktionengpt_academic Entwickler QQ-Gruppe-2: 610599535
-
-- Bekannte Probleme
- - Einige Browser-Übersetzungs-Plugins können die Frontend-Ausführung dieser Software stören.
- - Sowohl eine zu hohe als auch eine zu niedrige Version von Gradio führt zu verschiedenen Ausnahmen.
-
-## Referenz und Lernen
-
-```
-Der Code bezieht sich auf viele Designs von anderen herausragenden Projekten, insbesondere:
-
-# Projekt 1: ChatGLM-6B der Tsinghua Universität:
-https://github.com/THUDM/ChatGLM-6B
-
-# Projekt 2: JittorLLMs der Tsinghua Universität:
-https://github.com/Jittor/JittorLLMs
-
-# Projekt 3: Edge-GPT:
-https://github.com/acheong08/EdgeGPT
-
-# Projekt 4: ChuanhuChatGPT:
-https://github.com/GaiZhenbiao/ChuanhuChatGPT
-
-# Projekt 5: ChatPaper:
-https://github.com/kaixindelele/ChatPaper
-
-# Mehr:
-https://github.com/gradio-app/gradio
-https://github.com/fghrsh/live2d_demo
-```
\ No newline at end of file
diff --git a/spaces/Mellow-ai/PhotoAI_Mellow/annotator/uniformer/configs/_base_/models/dmnet_r50-d8.py b/spaces/Mellow-ai/PhotoAI_Mellow/annotator/uniformer/configs/_base_/models/dmnet_r50-d8.py
deleted file mode 100644
index d22ba52640bebd805b3b8d07025e276dfb023759..0000000000000000000000000000000000000000
--- a/spaces/Mellow-ai/PhotoAI_Mellow/annotator/uniformer/configs/_base_/models/dmnet_r50-d8.py
+++ /dev/null
@@ -1,44 +0,0 @@
-# model settings
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
- type='EncoderDecoder',
- pretrained='open-mmlab://resnet50_v1c',
- backbone=dict(
- type='ResNetV1c',
- depth=50,
- num_stages=4,
- out_indices=(0, 1, 2, 3),
- dilations=(1, 1, 2, 4),
- strides=(1, 2, 1, 1),
- norm_cfg=norm_cfg,
- norm_eval=False,
- style='pytorch',
- contract_dilation=True),
- decode_head=dict(
- type='DMHead',
- in_channels=2048,
- in_index=3,
- channels=512,
- filter_sizes=(1, 3, 5, 7),
- dropout_ratio=0.1,
- num_classes=19,
- norm_cfg=dict(type='SyncBN', requires_grad=True),
- align_corners=False,
- loss_decode=dict(
- type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
- auxiliary_head=dict(
- type='FCNHead',
- in_channels=1024,
- in_index=2,
- channels=256,
- num_convs=1,
- concat_input=False,
- dropout_ratio=0.1,
- num_classes=19,
- norm_cfg=norm_cfg,
- align_corners=False,
- loss_decode=dict(
- type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
- # model training and testing settings
- train_cfg=dict(),
- test_cfg=dict(mode='whole'))
diff --git a/spaces/Mellow-ai/PhotoAI_Mellow/annotator/uniformer/mmseg/core/evaluation/metrics.py b/spaces/Mellow-ai/PhotoAI_Mellow/annotator/uniformer/mmseg/core/evaluation/metrics.py
deleted file mode 100644
index 16c7dd47cadd53cf1caaa194e28a343f2aacc599..0000000000000000000000000000000000000000
--- a/spaces/Mellow-ai/PhotoAI_Mellow/annotator/uniformer/mmseg/core/evaluation/metrics.py
+++ /dev/null
@@ -1,326 +0,0 @@
-from collections import OrderedDict
-
-import annotator.uniformer.mmcv as mmcv
-import numpy as np
-import torch
-
-
-def f_score(precision, recall, beta=1):
- """calcuate the f-score value.
-
- Args:
- precision (float | torch.Tensor): The precision value.
- recall (float | torch.Tensor): The recall value.
- beta (int): Determines the weight of recall in the combined score.
- Default: False.
-
- Returns:
- [torch.tensor]: The f-score value.
- """
- score = (1 + beta**2) * (precision * recall) / (
- (beta**2 * precision) + recall)
- return score
-
-
-def intersect_and_union(pred_label,
- label,
- num_classes,
- ignore_index,
- label_map=dict(),
- reduce_zero_label=False):
- """Calculate intersection and Union.
-
- Args:
- pred_label (ndarray | str): Prediction segmentation map
- or predict result filename.
- label (ndarray | str): Ground truth segmentation map
- or label filename.
- num_classes (int): Number of categories.
- ignore_index (int): Index that will be ignored in evaluation.
- label_map (dict): Mapping old labels to new labels. The parameter will
- work only when label is str. Default: dict().
- reduce_zero_label (bool): Wether ignore zero label. The parameter will
- work only when label is str. Default: False.
-
- Returns:
- torch.Tensor: The intersection of prediction and ground truth
- histogram on all classes.
- torch.Tensor: The union of prediction and ground truth histogram on
- all classes.
- torch.Tensor: The prediction histogram on all classes.
- torch.Tensor: The ground truth histogram on all classes.
- """
-
- if isinstance(pred_label, str):
- pred_label = torch.from_numpy(np.load(pred_label))
- else:
- pred_label = torch.from_numpy((pred_label))
-
- if isinstance(label, str):
- label = torch.from_numpy(
- mmcv.imread(label, flag='unchanged', backend='pillow'))
- else:
- label = torch.from_numpy(label)
-
- if label_map is not None:
- for old_id, new_id in label_map.items():
- label[label == old_id] = new_id
- if reduce_zero_label:
- label[label == 0] = 255
- label = label - 1
- label[label == 254] = 255
-
- mask = (label != ignore_index)
- pred_label = pred_label[mask]
- label = label[mask]
-
- intersect = pred_label[pred_label == label]
- area_intersect = torch.histc(
- intersect.float(), bins=(num_classes), min=0, max=num_classes - 1)
- area_pred_label = torch.histc(
- pred_label.float(), bins=(num_classes), min=0, max=num_classes - 1)
- area_label = torch.histc(
- label.float(), bins=(num_classes), min=0, max=num_classes - 1)
- area_union = area_pred_label + area_label - area_intersect
- return area_intersect, area_union, area_pred_label, area_label
-
-
-def total_intersect_and_union(results,
- gt_seg_maps,
- num_classes,
- ignore_index,
- label_map=dict(),
- reduce_zero_label=False):
- """Calculate Total Intersection and Union.
-
- Args:
- results (list[ndarray] | list[str]): List of prediction segmentation
- maps or list of prediction result filenames.
- gt_seg_maps (list[ndarray] | list[str]): list of ground truth
- segmentation maps or list of label filenames.
- num_classes (int): Number of categories.
- ignore_index (int): Index that will be ignored in evaluation.
- label_map (dict): Mapping old labels to new labels. Default: dict().
- reduce_zero_label (bool): Wether ignore zero label. Default: False.
-
- Returns:
- ndarray: The intersection of prediction and ground truth histogram
- on all classes.
- ndarray: The union of prediction and ground truth histogram on all
- classes.
- ndarray: The prediction histogram on all classes.
- ndarray: The ground truth histogram on all classes.
- """
- num_imgs = len(results)
- assert len(gt_seg_maps) == num_imgs
- total_area_intersect = torch.zeros((num_classes, ), dtype=torch.float64)
- total_area_union = torch.zeros((num_classes, ), dtype=torch.float64)
- total_area_pred_label = torch.zeros((num_classes, ), dtype=torch.float64)
- total_area_label = torch.zeros((num_classes, ), dtype=torch.float64)
- for i in range(num_imgs):
- area_intersect, area_union, area_pred_label, area_label = \
- intersect_and_union(
- results[i], gt_seg_maps[i], num_classes, ignore_index,
- label_map, reduce_zero_label)
- total_area_intersect += area_intersect
- total_area_union += area_union
- total_area_pred_label += area_pred_label
- total_area_label += area_label
- return total_area_intersect, total_area_union, total_area_pred_label, \
- total_area_label
-
-
-def mean_iou(results,
- gt_seg_maps,
- num_classes,
- ignore_index,
- nan_to_num=None,
- label_map=dict(),
- reduce_zero_label=False):
- """Calculate Mean Intersection and Union (mIoU)
-
- Args:
- results (list[ndarray] | list[str]): List of prediction segmentation
- maps or list of prediction result filenames.
- gt_seg_maps (list[ndarray] | list[str]): list of ground truth
- segmentation maps or list of label filenames.
- num_classes (int): Number of categories.
- ignore_index (int): Index that will be ignored in evaluation.
- nan_to_num (int, optional): If specified, NaN values will be replaced
- by the numbers defined by the user. Default: None.
- label_map (dict): Mapping old labels to new labels. Default: dict().
- reduce_zero_label (bool): Wether ignore zero label. Default: False.
-
- Returns:
- dict[str, float | ndarray]:
- Predict whether a data row describes a fire hazard or not.
\ -Here is a Google Sheets document containing sample data (You can use for testing). It is a heavy document so it might take a while to load.",
- output_description="Prediction",
- examples=[['-26.76123, 147.15512, 393.02, 203.63'], ['-26.7598, 147.14514, 361.54, 79.4'], ['-25.70059, 149.48932, 313.9, 5.15'], ['-24.4318, 151.83102, 307.98, 8.79'], ['-23.21878, 148.91298, 314.08, 7.4'], ['7.87518, 19.9241, 316.32, 39.63'], ['-20.10942, 148.14326, 314.39, 8.8'], ['7.87772, 19.9048, 304.14, 13.43'], ['-20.79866, 124.46834, 366.74, 89.06']],
- theme="Streamlit",
- css=custom_style
-)
-io.launch()
diff --git a/spaces/Norod78/SillyTedTalkSnippetGenerator/README.md b/spaces/Norod78/SillyTedTalkSnippetGenerator/README.md
deleted file mode 100644
index e733521a0fa2780c765b1c90ba666a1ffbf1726a..0000000000000000000000000000000000000000
--- a/spaces/Norod78/SillyTedTalkSnippetGenerator/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Silly Ted-Talk Snippet Generator
-emoji: 🧑🏫
-colorFrom: green
-colorTo: pink
-sdk: gradio
-sdk_version: 3.1.1
-app_file: app.py
-pinned: false
-license: cc-by-nc-4.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/OFA-Sys/OFA-Generic_Interface/data/ofa_dataset.py b/spaces/OFA-Sys/OFA-Generic_Interface/data/ofa_dataset.py
deleted file mode 100644
index 02d856c28016b3a1c020fed483afe0aa797bf50f..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Generic_Interface/data/ofa_dataset.py
+++ /dev/null
@@ -1,74 +0,0 @@
-import logging
-import re
-import torch.utils.data
-from fairseq.data import FairseqDataset
-
-logger = logging.getLogger(__name__)
-
-
-class OFADataset(FairseqDataset):
- def __init__(self, split, dataset, bpe, src_dict, tgt_dict):
- self.split = split
- self.dataset = dataset
- self.bpe = bpe
- self.src_dict = src_dict
- self.tgt_dict = tgt_dict
-
- self.bos = src_dict.bos()
- self.eos = src_dict.eos()
- self.pad = src_dict.pad()
- self.bos_item = torch.LongTensor([self.bos])
- self.eos_item = torch.LongTensor([self.eos])
-
- def __len__(self):
- return len(self.dataset)
-
- def encode_text(self, text, length=None, append_bos=False, append_eos=False, use_bpe=True):
- s = self.tgt_dict.encode_line(
- line=self.bpe.encode(text) if use_bpe else text,
- add_if_not_exist=False,
- append_eos=False
- ).long()
- if length is not None:
- s = s[:length]
- if append_bos:
- s = torch.cat([self.bos_item, s])
- if append_eos:
- s = torch.cat([s, self.eos_item])
- return s
-
- def pre_question(self, question, max_ques_words):
- question = question.lower().lstrip(",.!?*#:;~").replace('-', ' ').replace('/', ' ')
-
- question = re.sub(
- r"\s{2,}",
- ' ',
- question,
- )
- question = question.rstrip('\n')
- question = question.strip(' ')
-
- # truncate question
- question_words = question.split(' ')
- if len(question_words) > max_ques_words:
- question = ' '.join(question_words[:max_ques_words])
-
- return question
-
- def pre_caption(self, caption, max_words):
- caption = caption.lower().lstrip(",.!?*#:;~").replace('-', ' ').replace('/', ' ').replace('', 'person')
-
- caption = re.sub(
- r"\s{2,}",
- ' ',
- caption,
- )
- caption = caption.rstrip('\n')
- caption = caption.strip(' ')
-
- # truncate caption
- caption_words = caption.split(' ')
- if len(caption_words) > max_words:
- caption = ' '.join(caption_words[:max_words])
-
- return caption
diff --git a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/hubert/simple_kmeans/dump_hubert_feature_s2t.py b/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/hubert/simple_kmeans/dump_hubert_feature_s2t.py
deleted file mode 100644
index 6fff4faf44a92d42504559ecea8ec1047d2e5f14..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/hubert/simple_kmeans/dump_hubert_feature_s2t.py
+++ /dev/null
@@ -1,92 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import csv
-import io
-import logging
-import os
-import os.path as op
-import sys
-
-from dump_hubert_feature import HubertFeatureReader
-from feature_utils import get_shard_range, dump_feature
-from fairseq.data.audio.audio_utils import get_waveform
-from fairseq.data.audio.speech_to_text_dataset import (
- read_from_uncompressed_zip,
-)
-
-
-logging.basicConfig(
- format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
- datefmt="%Y-%m-%d %H:%M:%S",
- level=os.environ.get("LOGLEVEL", "INFO").upper(),
- stream=sys.stdout,
-)
-logger = logging.getLogger("dump_hubert_feature_s2t")
-
-
-class HubertFeatureReaderS2T(HubertFeatureReader):
- def read_audio(self, path, ref_len=None):
- path, *extra = path.split(":")
- assert len(extra) == 2
- assert path.endswith(".zip")
-
- data = read_from_uncompressed_zip(path, int(extra[0]), int(extra[1]))
- f = io.BytesIO(data)
- wav, sr = get_waveform(f)
- assert sr == self.task.cfg.sample_rate, sr
- if wav.ndim == 2:
- wav = wav.mean(-1)
- assert wav.ndim == 1, wav.ndim
- if ref_len is not None and abs(ref_len - len(wav)) > 160:
- logging.warning(f"ref {ref_len} != read {len(wav)} ({path})")
- return wav
-
-
-def get_path_iterator(root, tsv, nshard, rank):
- with open(tsv) as f:
- reader = csv.DictReader(
- f,
- delimiter="\t",
- quotechar=None,
- doublequote=False,
- lineterminator="\n",
- quoting=csv.QUOTE_NONE,
- )
- subpaths = [op.join(root, e["audio"]) for e in reader]
- start, end = get_shard_range(len(subpaths), nshard, rank)
- subpaths = subpaths[start:end]
- def iterate():
- for subpath in subpaths:
- yield op.join(root, subpath), None
- return iterate, len(subpaths)
-
-
-def main(
- root, tsv_path, ckpt_path, layer, nshard, rank, feat_dir, split, max_chunk
-):
- reader = HubertFeatureReaderS2T(ckpt_path, layer, max_chunk)
- generator, num = get_path_iterator(root, tsv_path, nshard, rank)
- dump_feature(reader, generator, num, split, nshard, rank, feat_dir)
-
-
-
-if __name__ == "__main__":
- import argparse
-
- parser = argparse.ArgumentParser()
- parser.add_argument("root")
- parser.add_argument("tsv_path")
- parser.add_argument("ckpt_path")
- parser.add_argument("layer", type=int)
- parser.add_argument("nshard", type=int)
- parser.add_argument("rank", type=int)
- parser.add_argument("feat_dir")
- parser.add_argument("split")
- parser.add_argument("--max_chunk", type=int, default=1600000)
- args = parser.parse_args()
- logger.info(args)
-
- main(**vars(args))
diff --git a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/speech_synthesis/preprocessing/denoise_and_vad_audio.py b/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/speech_synthesis/preprocessing/denoise_and_vad_audio.py
deleted file mode 100644
index 4e13b38a5d3fb44dd3969e6afcb8f202274ee3b7..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/examples/speech_synthesis/preprocessing/denoise_and_vad_audio.py
+++ /dev/null
@@ -1,204 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import argparse
-import logging
-import os
-import csv
-import tempfile
-from collections import defaultdict
-from pathlib import Path
-
-import torchaudio
-try:
- import webrtcvad
-except ImportError:
- raise ImportError("Please install py-webrtcvad: pip install webrtcvad")
-import pandas as pd
-from tqdm import tqdm
-
-from examples.speech_synthesis.preprocessing.denoiser.pretrained import master64
-import examples.speech_synthesis.preprocessing.denoiser.utils as utils
-from examples.speech_synthesis.preprocessing.vad import (
- frame_generator, vad_collector, read_wave, write_wave, FS_MS, THRESHOLD,
- SCALE
-)
-from examples.speech_to_text.data_utils import save_df_to_tsv
-
-
-log = logging.getLogger(__name__)
-
-PATHS = ["after_denoise", "after_vad"]
-MIN_T = 0.05
-
-
-def generate_tmp_filename(extension="txt"):
- return tempfile._get_default_tempdir() + "/" + \
- next(tempfile._get_candidate_names()) + "." + extension
-
-
-def convert_sr(inpath, sr, output_path=None):
- if not output_path:
- output_path = generate_tmp_filename("wav")
- cmd = f"sox {inpath} -r {sr} {output_path}"
- os.system(cmd)
- return output_path
-
-
-def apply_vad(vad, inpath):
- audio, sample_rate = read_wave(inpath)
- frames = frame_generator(FS_MS, audio, sample_rate)
- frames = list(frames)
- segments = vad_collector(sample_rate, FS_MS, 300, vad, frames)
- merge_segments = list()
- timestamp_start = 0.0
- timestamp_end = 0.0
- # removing start, end, and long sequences of sils
- for i, segment in enumerate(segments):
- merge_segments.append(segment[0])
- if i and timestamp_start:
- sil_duration = segment[1] - timestamp_end
- if sil_duration > THRESHOLD:
- merge_segments.append(int(THRESHOLD / SCALE) * (b'\x00'))
- else:
- merge_segments.append(int((sil_duration / SCALE)) * (b'\x00'))
- timestamp_start = segment[1]
- timestamp_end = segment[2]
- segment = b''.join(merge_segments)
- return segment, sample_rate
-
-
-def write(wav, filename, sr=16_000):
- # Normalize audio if it prevents clipping
- wav = wav / max(wav.abs().max().item(), 1)
- torchaudio.save(filename, wav.cpu(), sr, encoding="PCM_S",
- bits_per_sample=16)
-
-
-def process(args):
- # making sure we are requested either denoise or vad
- if not args.denoise and not args.vad:
- log.error("No denoise or vad is requested.")
- return
-
- log.info("Creating out directories...")
- if args.denoise:
- out_denoise = Path(args.output_dir).absolute().joinpath(PATHS[0])
- out_denoise.mkdir(parents=True, exist_ok=True)
- if args.vad:
- out_vad = Path(args.output_dir).absolute().joinpath(PATHS[1])
- out_vad.mkdir(parents=True, exist_ok=True)
-
- log.info("Loading pre-trained speech enhancement model...")
- model = master64().to(args.device)
-
- log.info("Building the VAD model...")
- vad = webrtcvad.Vad(int(args.vad_agg_level))
-
- # preparing the output dict
- output_dict = defaultdict(list)
-
- log.info(f"Parsing input manifest: {args.audio_manifest}")
- with open(args.audio_manifest, "r") as f:
- manifest_dict = csv.DictReader(f, delimiter="\t")
- for row in tqdm(manifest_dict):
- filename = str(row["audio"])
-
- final_output = filename
- keep_sample = True
- n_frames = row["n_frames"]
- snr = -1
- if args.denoise:
- output_path_denoise = out_denoise.joinpath(Path(filename).name)
- # convert to 16khz in case we use a differet sr
- tmp_path = convert_sr(final_output, 16000)
-
- # loading audio file and generating the enhanced version
- out, sr = torchaudio.load(tmp_path)
- out = out.to(args.device)
- estimate = model(out)
- estimate = (1 - args.dry_wet) * estimate + args.dry_wet * out
- write(estimate[0], str(output_path_denoise), sr)
-
- snr = utils.cal_snr(out, estimate)
- snr = snr.cpu().detach().numpy()[0][0]
- final_output = str(output_path_denoise)
-
- if args.vad:
- output_path_vad = out_vad.joinpath(Path(filename).name)
- sr = torchaudio.info(final_output).sample_rate
- if sr in [16000, 32000, 48000]:
- tmp_path = final_output
- elif sr < 16000:
- tmp_path = convert_sr(final_output, 16000)
- elif sr < 32000:
- tmp_path = convert_sr(final_output, 32000)
- else:
- tmp_path = convert_sr(final_output, 48000)
- # apply VAD
- segment, sample_rate = apply_vad(vad, tmp_path)
- if len(segment) < sample_rate * MIN_T:
- keep_sample = False
- print((
- f"WARNING: skip {filename} because it is too short "
- f"after VAD ({len(segment) / sample_rate} < {MIN_T})"
- ))
- else:
- if sample_rate != sr:
- tmp_path = generate_tmp_filename("wav")
- write_wave(tmp_path, segment, sample_rate)
- convert_sr(tmp_path, sr,
- output_path=str(output_path_vad))
- else:
- write_wave(str(output_path_vad), segment, sample_rate)
- final_output = str(output_path_vad)
- segment, _ = torchaudio.load(final_output)
- n_frames = segment.size(1)
-
- if keep_sample:
- output_dict["id"].append(row["id"])
- output_dict["audio"].append(final_output)
- output_dict["n_frames"].append(n_frames)
- output_dict["tgt_text"].append(row["tgt_text"])
- output_dict["speaker"].append(row["speaker"])
- output_dict["src_text"].append(row["src_text"])
- output_dict["snr"].append(snr)
-
- out_tsv_path = Path(args.output_dir) / Path(args.audio_manifest).name
- log.info(f"Saving manifest to {out_tsv_path.as_posix()}")
- save_df_to_tsv(pd.DataFrame.from_dict(output_dict), out_tsv_path)
-
-
-def main():
- parser = argparse.ArgumentParser()
- parser.add_argument("--audio-manifest", "-i", required=True,
- type=str, help="path to the input manifest.")
- parser.add_argument(
- "--output-dir", "-o", required=True, type=str,
- help="path to the output dir. it will contain files after denoising and"
- " vad"
- )
- parser.add_argument("--vad-agg-level", "-a", type=int, default=2,
- help="the aggresive level of the vad [0-3].")
- parser.add_argument(
- "--dry-wet", "-dw", type=float, default=0.01,
- help="the level of linear interpolation between noisy and enhanced "
- "files."
- )
- parser.add_argument(
- "--device", "-d", type=str, default="cpu",
- help="the device to be used for the speech enhancement model: "
- "cpu | cuda."
- )
- parser.add_argument("--denoise", action="store_true",
- help="apply a denoising")
- parser.add_argument("--vad", action="store_true", help="apply a VAD")
- args = parser.parse_args()
-
- process(args)
-
-
-if __name__ == "__main__":
- main()
diff --git a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/fairseq/data/encoders/gpt2_bpe.py b/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/fairseq/data/encoders/gpt2_bpe.py
deleted file mode 100644
index b7426b249bbbabd8e20bbe8ca5449809efdf85fc..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Generic_Interface/fairseq/fairseq/data/encoders/gpt2_bpe.py
+++ /dev/null
@@ -1,45 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-from dataclasses import dataclass, field
-
-from fairseq import file_utils
-from fairseq.data.encoders import register_bpe
-from fairseq.dataclass import FairseqDataclass
-
-from .gpt2_bpe_utils import get_encoder
-
-
-DEFAULT_ENCODER_JSON = "https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/encoder.json"
-DEFAULT_VOCAB_BPE = "https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/vocab.bpe"
-
-
-@dataclass
-class GPT2BPEConfig(FairseqDataclass):
- gpt2_encoder_json: str = field(
- default=DEFAULT_ENCODER_JSON, metadata={"help": "path to encoder.json"}
- )
- gpt2_vocab_bpe: str = field(
- default=DEFAULT_VOCAB_BPE, metadata={"help": "path to vocab.bpe"}
- )
-
-
-@register_bpe("gpt2", dataclass=GPT2BPEConfig)
-class GPT2BPE(object):
- def __init__(self, cfg):
- encoder_json = file_utils.cached_path(cfg.gpt2_encoder_json)
- vocab_bpe = file_utils.cached_path(cfg.gpt2_vocab_bpe)
- self.bpe = get_encoder(encoder_json, vocab_bpe)
-
- def encode(self, x: str) -> str:
- return " ".join(map(str, self.bpe.encode(x)))
-
- def decode(self, x: str) -> str:
- return self.bpe.decode(
- [int(tok) if tok not in {"", ""} and not tok.startswith('<') else tok for tok in x.split()]
- )
-
- def is_beginning_of_word(self, x: str) -> bool:
- return self.decode(x).startswith(" ")
diff --git a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/data/resampling_dataset.py b/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/data/resampling_dataset.py
deleted file mode 100644
index 3d3b993164dc3962df48bacff26714328e843e80..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/data/resampling_dataset.py
+++ /dev/null
@@ -1,139 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import logging
-
-import numpy as np
-from fairseq.data import BaseWrapperDataset, plasma_utils
-
-
-logger = logging.getLogger(__name__)
-
-
-class ResamplingDataset(BaseWrapperDataset):
- """Randomly samples from a given dataset at each epoch.
-
- Sampling is done with or without replacement, depending on the "replace"
- parameter.
-
- Optionally, the epoch size can be rescaled. This is potentially desirable
- to increase per-epoch coverage of the base dataset (since sampling with
- replacement means that many items in the dataset will be left out). In the
- case of sampling without replacement, size_ratio should be strictly less
- than 1.
-
- Args:
- dataset (~torch.utils.data.Dataset): dataset on which to sample.
- weights (List[float]): list of probability weights
- (default: None, which corresponds to uniform sampling).
- replace (bool): sampling mode; True for "with replacement", or False
- for "without replacement" (default: True)
- size_ratio (float): the ratio to subsample to; must be positive
- (default: 1.0).
- batch_by_size (bool): whether or not to batch by sequence length
- (default: True).
- seed (int): RNG seed to use (default: 0).
- epoch (int): starting epoch number (default: 1).
- """
-
- def __init__(
- self,
- dataset,
- weights=None,
- replace=True,
- size_ratio=1.0,
- batch_by_size=True,
- seed=0,
- epoch=1,
- ):
- super().__init__(dataset)
-
- if weights is None:
- self.weights = None
-
- else:
- assert len(weights) == len(dataset)
- weights_arr = np.array(weights, dtype=np.float64)
- weights_arr /= weights_arr.sum()
- self.weights = plasma_utils.PlasmaArray(weights_arr)
-
- self.replace = replace
-
- assert size_ratio > 0.0
- if not self.replace:
- assert size_ratio < 1.0
- self.size_ratio = float(size_ratio)
- self.actual_size = np.ceil(len(dataset) * self.size_ratio).astype(int)
-
- self.batch_by_size = batch_by_size
- self.seed = seed
-
- self._cur_epoch = None
- self._cur_indices = None
-
- self.set_epoch(epoch)
-
- def __getitem__(self, index):
- return self.dataset[self._cur_indices.array[index]]
-
- def __len__(self):
- return self.actual_size
-
- @property
- def sizes(self):
- if isinstance(self.dataset.sizes, list):
- return [s[self._cur_indices.array] for s in self.dataset.sizes]
- return self.dataset.sizes[self._cur_indices.array]
-
- def num_tokens(self, index):
- return self.dataset.num_tokens(self._cur_indices.array[index])
-
- def size(self, index):
- return self.dataset.size(self._cur_indices.array[index])
-
- def ordered_indices(self):
- if self.batch_by_size:
- order = [
- np.arange(len(self)),
- self.sizes,
- ] # No need to handle `self.shuffle == True`
- return np.lexsort(order)
- else:
- return np.arange(len(self))
-
- def prefetch(self, indices):
- self.dataset.prefetch(self._cur_indices.array[indices])
-
- @property
- def can_reuse_epoch_itr_across_epochs(self):
- return False
-
- def set_epoch(self, epoch):
- logger.debug("ResamplingDataset.set_epoch: {}".format(epoch))
- super().set_epoch(epoch)
-
- if epoch == self._cur_epoch:
- return
-
- self._cur_epoch = epoch
-
- # Generate a weighted sample of indices as a function of the
- # random seed and the current epoch.
-
- rng = np.random.RandomState(
- [
- 42, # magic number
- self.seed % (2 ** 32), # global seed
- self._cur_epoch, # epoch index
- ]
- )
- self._cur_indices = plasma_utils.PlasmaArray(
- rng.choice(
- len(self.dataset),
- self.actual_size,
- replace=self.replace,
- p=(None if self.weights is None else self.weights.array),
- )
- )
diff --git a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/modules/quantization/scalar/__init__.py b/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/modules/quantization/scalar/__init__.py
deleted file mode 100644
index 143834f3d036780eb6844c82f0c6f2d10cfe2f61..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/modules/quantization/scalar/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-from .utils import quantize_model_ # NOQA
diff --git a/spaces/OFA-Sys/OFA-vqa/fairseq/examples/laser/laser_src/multitask_data_utils.py b/spaces/OFA-Sys/OFA-vqa/fairseq/examples/laser/laser_src/multitask_data_utils.py
deleted file mode 100644
index b05caea26793bf5112a7abc29d76225f578f3ebe..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-vqa/fairseq/examples/laser/laser_src/multitask_data_utils.py
+++ /dev/null
@@ -1,143 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-from collections import OrderedDict
-
-import numpy as np
-
-from fairseq.data import BaseWrapperDataset, FairseqDataset, iterators
-
-
-class MultiItr(object):
- def __init__(self, itr):
- self.itr = itr
- self._counts = [0 for x in itr]
-
- def __len__(self):
- return sum(len(itr) for itr in self.itr)
-
- def __iter__(self):
- return self
-
- def __next__(self):
- ratios = [count / len(itr) for count, itr in zip(self._counts, self.itr)]
- idx = ratios.index(min(ratios))
- self._counts[idx] += 1
- return next(self.itr[idx])
-
-
-class MultidatasetEpochBatchIterator(iterators.EpochBatchIterating):
- """A wrapper around multiple epoch batch iterators."""
-
- def __init__(
- self,
- dataset,
- batch_sampler,
- seed=1,
- num_shards=1,
- shard_id=0,
- num_workers=0,
- epoch=1,
- ):
-
- assert isinstance(dataset, OrderedDict)
- assert len(dataset)
- assert isinstance(dataset[next(iter(dataset))], FairseqDataset)
-
- self.iterators = []
-
- self.epoch = epoch
- for key, dt in dataset.items():
- epoch_iter = iterators.EpochBatchIterator(
- dataset=dt,
- collate_fn=dt.collater,
- batch_sampler=batch_sampler[key],
- seed=seed,
- num_shards=num_shards,
- shard_id=shard_id,
- num_workers=0,
- epoch=epoch,
- )
- self.iterators.append(epoch_iter)
-
- def __len__(self):
- return sum(len(itr) for itr in self.iterators)
-
- def next_epoch_itr(self, shuffle=True, fix_batches_to_gpus=False):
- # `self.epoch += 1` should be handled by underlying `EpochBatchIterator`s.
- return MultiItr(
- [
- itr.next_epoch_itr(
- shuffle=shuffle, fix_batches_to_gpus=fix_batches_to_gpus
- )
- for itr in self.iterators
- ]
- )
-
- def end_of_epoch(self):
- return all(itr.end_of_epoch() for itr in self.iterators)
-
- @property
- def next_epoch_idx(self):
- """Return the epoch index after *next_epoch_itr* is called."""
-
- epochs = [itr.next_epoch_idx for itr in self.iterators]
- self.epoch = epochs[0]
- assert all(epoch == self.epoch for epoch in epochs)
-
- return self.epoch
-
- @property
- def iterations_in_epoch(self):
- return sum(itr.iterations_in_epoch for itr in self.iterators)
-
- def state_dict(self):
- return {
- "iterators": [it.state_dict() for it in self.iterators],
- "epoch": self.epoch,
- }
-
- def load_state_dict(self, state_dict):
- self.epoch = state_dict["epoch"]
- for it, d in zip(self.iterators, state_dict["iterators"]):
- it.load_state_dict(d)
-
-
-class MultitaskDatasetWrapper(BaseWrapperDataset):
- """A wrapper for a multitask dataset."""
-
- def __init__(self, dataset, target_language_id, sample=1.0, name=""):
- super().__init__(dataset)
- self.target_language_id = target_language_id
- self.sample = sample
- self.name = name
-
- def collater(self, *args, **kwargs):
- ans = self.dataset.collater(*args, **kwargs)
- if "net_input" in ans:
- ans["net_input"]["target_language_id"] = self.target_language_id
- ans["net_input"]["dataset_name"] = self.name
- return ans
-
- def num_tokens(self, *args, **kwargs):
- return self.dataset.num_tokens(*args, **kwargs)
-
- def ordered_indices(self, *args, **kwargs):
- indices = self.dataset.ordered_indices(*args, **kwargs)
- # Hacky solution for sampling
- size = int(self.sample * indices.shape[0])
-
- return indices.take(np.sort(np.random.permutation(indices.shape[0])[:size]))
-
- def size(self, index: int):
- return self.dataset.size(index)
-
- @property
- def supports_prefetch(self):
- """Whether this dataset supports prefetching."""
- return getattr(self.dataset, "supports_prefetch", False)
-
- def prefetch(self, indices):
- return self.dataset.prefetch(indices)
diff --git a/spaces/OFA-Sys/OFA-vqa/fairseq/examples/noisychannel/__init__.py b/spaces/OFA-Sys/OFA-vqa/fairseq/examples/noisychannel/__init__.py
deleted file mode 100644
index 89f1aef4f6328d25425e0bcabb42dfffd2ed35f0..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-vqa/fairseq/examples/noisychannel/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-from .rerank_options import * # noqa
diff --git a/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/modules/transformer_layer.py b/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/modules/transformer_layer.py
deleted file mode 100644
index 347b8118daa2818af5e0230a793f2fa8fcd63b3a..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/modules/transformer_layer.py
+++ /dev/null
@@ -1,459 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-from typing import Dict, List, Optional
-
-import torch
-import torch.nn as nn
-from fairseq import utils
-from fairseq.modules import LayerNorm, MultiheadAttention
-from fairseq.modules.fairseq_dropout import FairseqDropout
-from fairseq.modules.quant_noise import quant_noise
-from torch import Tensor
-from fairseq.models.transformer import (
- TransformerConfig,
-)
-
-
-class TransformerEncoderLayerBase(nn.Module):
- """Encoder layer block.
-
- In the original paper each operation (multi-head attention or FFN) is
- postprocessed with: `dropout -> add residual -> layernorm`. In the
- tensor2tensor code they suggest that learning is more robust when
- preprocessing each layer with layernorm and postprocessing with:
- `dropout -> add residual`. We default to the approach in the paper, but the
- tensor2tensor approach can be enabled by setting
- *cfg.encoder.normalize_before* to ``True``.
-
- Args:
- args (argparse.Namespace): parsed command-line arguments
- """
-
- def __init__(self, cfg):
- super().__init__()
- self.cfg = cfg
- self.embed_dim = cfg.encoder.embed_dim
- self.quant_noise = cfg.quant_noise.pq
- self.quant_noise_block_size = cfg.quant_noise.pq_block_size
- self.self_attn = self.build_self_attention(self.embed_dim, cfg)
- self.self_attn_layer_norm = LayerNorm(self.embed_dim, export=cfg.export)
- self.dropout_module = FairseqDropout(
- cfg.dropout, module_name=self.__class__.__name__
- )
- self.activation_fn = utils.get_activation_fn(activation=cfg.activation_fn)
- activation_dropout_p = cfg.activation_dropout
- if activation_dropout_p == 0:
- # for backwards compatibility with models that use cfg.relu_dropout
- activation_dropout_p = cfg.relu_dropout or 0
- self.activation_dropout_module = FairseqDropout(
- float(activation_dropout_p), module_name=self.__class__.__name__
- )
- self.normalize_before = cfg.encoder.normalize_before
- self.fc1 = self.build_fc1(
- self.embed_dim,
- cfg.encoder.ffn_embed_dim,
- self.quant_noise,
- self.quant_noise_block_size,
- )
- self.fc2 = self.build_fc2(
- cfg.encoder.ffn_embed_dim,
- self.embed_dim,
- self.quant_noise,
- self.quant_noise_block_size,
- )
-
- self.final_layer_norm = LayerNorm(self.embed_dim, export=cfg.export)
-
- def build_fc1(self, input_dim, output_dim, q_noise, qn_block_size):
- return quant_noise(
- nn.Linear(input_dim, output_dim), p=q_noise, block_size=qn_block_size
- )
-
- def build_fc2(self, input_dim, output_dim, q_noise, qn_block_size):
- return quant_noise(
- nn.Linear(input_dim, output_dim), p=q_noise, block_size=qn_block_size
- )
-
- def build_self_attention(self, embed_dim, cfg):
- return MultiheadAttention(
- embed_dim,
- cfg.encoder.attention_heads,
- dropout=cfg.attention_dropout,
- self_attention=True,
- q_noise=self.quant_noise,
- qn_block_size=self.quant_noise_block_size,
- )
-
- def residual_connection(self, x, residual):
- return residual + x
-
- def upgrade_state_dict_named(self, state_dict, name):
- """
- Rename layer norm states from `...layer_norms.0.weight` to
- `...self_attn_layer_norm.weight` and `...layer_norms.1.weight` to
- `...final_layer_norm.weight`
- """
- layer_norm_map = {"0": "self_attn_layer_norm", "1": "final_layer_norm"}
- for old, new in layer_norm_map.items():
- for m in ("weight", "bias"):
- k = "{}.layer_norms.{}.{}".format(name, old, m)
- if k in state_dict:
- state_dict["{}.{}.{}".format(name, new, m)] = state_dict[k]
- del state_dict[k]
-
- def forward(
- self,
- x,
- encoder_padding_mask: Optional[Tensor],
- attn_mask: Optional[Tensor] = None,
- ):
- """
- Args:
- x (Tensor): input to the layer of shape `(seq_len, batch, embed_dim)`
- encoder_padding_mask (ByteTensor): binary ByteTensor of shape
- `(batch, seq_len)` where padding elements are indicated by ``1``.
- attn_mask (ByteTensor): binary tensor of shape `(tgt_len, src_len)`,
- where `tgt_len` is the length of output and `src_len` is the
- length of input, though here both are equal to `seq_len`.
- `attn_mask[tgt_i, src_j] = 1` means that when calculating the
- embedding for `tgt_i`, we exclude (mask out) `src_j`. This is
- useful for strided self-attention.
-
- Returns:
- encoded output of shape `(seq_len, batch, embed_dim)`
- """
- # anything in original attn_mask = 1, becomes -1e8
- # anything in original attn_mask = 0, becomes 0
- # Note that we cannot use -inf here, because at some edge cases,
- # the attention weight (before softmax) for some padded element in query
- # will become -inf, which results in NaN in model parameters
- if attn_mask is not None:
- attn_mask = attn_mask.masked_fill(
- attn_mask.to(torch.bool),
- -1e8 if x.dtype == torch.float32 else -1e4
- )
-
- residual = x
- if self.normalize_before:
- x = self.self_attn_layer_norm(x)
- x, _ = self.self_attn(
- query=x,
- key=x,
- value=x,
- key_padding_mask=encoder_padding_mask,
- need_weights=False,
- attn_mask=attn_mask,
- )
- x = self.dropout_module(x)
- x = self.residual_connection(x, residual)
- if not self.normalize_before:
- x = self.self_attn_layer_norm(x)
-
- residual = x
- if self.normalize_before:
- x = self.final_layer_norm(x)
- x = self.activation_fn(self.fc1(x))
- x = self.activation_dropout_module(x)
- x = self.fc2(x)
- x = self.dropout_module(x)
- x = self.residual_connection(x, residual)
- if not self.normalize_before:
- x = self.final_layer_norm(x)
- return x
-
-
-# backward compatible with the legacy argparse format
-class TransformerEncoderLayer(TransformerEncoderLayerBase):
- def __init__(self, args):
- super().__init__(TransformerConfig.from_namespace(args))
- self.args = args
-
- def build_self_attention(self, embed_dim, args):
- return super().build_self_attention(
- embed_dim, TransformerConfig.from_namespace(args)
- )
-
-
-class TransformerDecoderLayerBase(nn.Module):
- """Decoder layer block.
-
- In the original paper each operation (multi-head attention, encoder
- attention or FFN) is postprocessed with: `dropout -> add residual ->
- layernorm`. In the tensor2tensor code they suggest that learning is more
- robust when preprocessing each layer with layernorm and postprocessing with:
- `dropout -> add residual`. We default to the approach in the paper, but the
- tensor2tensor approach can be enabled by setting
- *cfg.decoder.normalize_before* to ``True``.
-
- Args:
- args (argparse.Namespace): parsed command-line arguments
- no_encoder_attn (bool, optional): whether to attend to encoder outputs
- (default: False).
- """
-
- def __init__(
- self, cfg, no_encoder_attn=False, add_bias_kv=False, add_zero_attn=False
- ):
- super().__init__()
- self.embed_dim = cfg.decoder.embed_dim
- self.dropout_module = FairseqDropout(
- cfg.dropout, module_name=self.__class__.__name__
- )
- self.quant_noise = cfg.quant_noise.pq
- self.quant_noise_block_size = cfg.quant_noise.pq_block_size
-
- self.cross_self_attention = cfg.cross_self_attention
-
- self.self_attn = self.build_self_attention(
- self.embed_dim,
- cfg,
- add_bias_kv=add_bias_kv,
- add_zero_attn=add_zero_attn,
- )
-
- self.activation_fn = utils.get_activation_fn(activation=cfg.activation_fn)
- activation_dropout_p = cfg.activation_dropout
- if activation_dropout_p == 0:
- # for backwards compatibility with models that use cfg.relu_dropout
- activation_dropout_p = cfg.relu_dropout or 0
- self.activation_dropout_module = FairseqDropout(
- float(activation_dropout_p), module_name=self.__class__.__name__
- )
- self.normalize_before = cfg.decoder.normalize_before
-
- self.self_attn_layer_norm = LayerNorm(self.embed_dim, export=cfg.export)
-
- if no_encoder_attn:
- self.encoder_attn = None
- self.encoder_attn_layer_norm = None
- else:
- self.encoder_attn = self.build_encoder_attention(self.embed_dim, cfg)
- self.encoder_attn_layer_norm = LayerNorm(self.embed_dim, export=cfg.export)
-
- self.fc1 = self.build_fc1(
- self.embed_dim,
- cfg.decoder.ffn_embed_dim,
- self.quant_noise,
- self.quant_noise_block_size,
- )
- self.fc2 = self.build_fc2(
- cfg.decoder.ffn_embed_dim,
- self.embed_dim,
- self.quant_noise,
- self.quant_noise_block_size,
- )
-
- self.final_layer_norm = LayerNorm(self.embed_dim, export=cfg.export)
- self.need_attn = True
-
- self.onnx_trace = False
-
- def build_fc1(self, input_dim, output_dim, q_noise, qn_block_size):
- return quant_noise(nn.Linear(input_dim, output_dim), q_noise, qn_block_size)
-
- def build_fc2(self, input_dim, output_dim, q_noise, qn_block_size):
- return quant_noise(nn.Linear(input_dim, output_dim), q_noise, qn_block_size)
-
- def build_self_attention(
- self, embed_dim, cfg, add_bias_kv=False, add_zero_attn=False
- ):
- return MultiheadAttention(
- embed_dim,
- cfg.decoder.attention_heads,
- dropout=cfg.attention_dropout,
- add_bias_kv=add_bias_kv,
- add_zero_attn=add_zero_attn,
- self_attention=not cfg.cross_self_attention,
- q_noise=self.quant_noise,
- qn_block_size=self.quant_noise_block_size,
- )
-
- def build_encoder_attention(self, embed_dim, cfg):
- return MultiheadAttention(
- embed_dim,
- cfg.decoder.attention_heads,
- kdim=cfg.encoder.embed_dim,
- vdim=cfg.encoder.embed_dim,
- dropout=cfg.attention_dropout,
- encoder_decoder_attention=True,
- q_noise=self.quant_noise,
- qn_block_size=self.quant_noise_block_size,
- )
-
- def prepare_for_onnx_export_(self):
- self.onnx_trace = True
-
- def residual_connection(self, x, residual):
- return residual + x
-
- def forward(
- self,
- x,
- encoder_out: Optional[torch.Tensor] = None,
- encoder_padding_mask: Optional[torch.Tensor] = None,
- incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None,
- prev_self_attn_state: Optional[List[torch.Tensor]] = None,
- prev_attn_state: Optional[List[torch.Tensor]] = None,
- self_attn_mask: Optional[torch.Tensor] = None,
- self_attn_padding_mask: Optional[torch.Tensor] = None,
- need_attn: bool = False,
- need_head_weights: bool = False,
- ):
- """
- Args:
- x (Tensor): input to the layer of shape `(seq_len, batch, embed_dim)`
- encoder_padding_mask (ByteTensor, optional): binary
- ByteTensor of shape `(batch, src_len)` where padding
- elements are indicated by ``1``.
- need_attn (bool, optional): return attention weights
- need_head_weights (bool, optional): return attention weights
- for each head (default: return average over heads).
-
- Returns:
- encoded output of shape `(seq_len, batch, embed_dim)`
- """
- if need_head_weights:
- need_attn = True
-
- residual = x
- if self.normalize_before:
- x = self.self_attn_layer_norm(x)
- if prev_self_attn_state is not None:
- prev_key, prev_value = prev_self_attn_state[:2]
- saved_state: Dict[str, Optional[Tensor]] = {
- "prev_key": prev_key,
- "prev_value": prev_value,
- }
- if len(prev_self_attn_state) >= 3:
- saved_state["prev_key_padding_mask"] = prev_self_attn_state[2]
- assert incremental_state is not None
- self.self_attn._set_input_buffer(incremental_state, saved_state)
- _self_attn_input_buffer = self.self_attn._get_input_buffer(incremental_state)
- if self.cross_self_attention and not (
- incremental_state is not None
- and _self_attn_input_buffer is not None
- and "prev_key" in _self_attn_input_buffer
- ):
- if self_attn_mask is not None:
- assert encoder_out is not None
- self_attn_mask = torch.cat(
- (x.new_zeros(x.size(0), encoder_out.size(0)), self_attn_mask), dim=1
- )
- if self_attn_padding_mask is not None:
- if encoder_padding_mask is None:
- assert encoder_out is not None
- encoder_padding_mask = self_attn_padding_mask.new_zeros(
- encoder_out.size(1), encoder_out.size(0)
- )
- self_attn_padding_mask = torch.cat(
- (encoder_padding_mask, self_attn_padding_mask), dim=1
- )
- assert encoder_out is not None
- y = torch.cat((encoder_out, x), dim=0)
- else:
- y = x
-
- x, attn = self.self_attn(
- query=x,
- key=y,
- value=y,
- key_padding_mask=self_attn_padding_mask,
- incremental_state=incremental_state,
- need_weights=False,
- attn_mask=self_attn_mask,
- )
- x = self.dropout_module(x)
- x = self.residual_connection(x, residual)
- if not self.normalize_before:
- x = self.self_attn_layer_norm(x)
-
- if self.encoder_attn is not None and encoder_out is not None:
- residual = x
- if self.normalize_before:
- x = self.encoder_attn_layer_norm(x)
- if prev_attn_state is not None:
- prev_key, prev_value = prev_attn_state[:2]
- saved_state: Dict[str, Optional[Tensor]] = {
- "prev_key": prev_key,
- "prev_value": prev_value,
- }
- if len(prev_attn_state) >= 3:
- saved_state["prev_key_padding_mask"] = prev_attn_state[2]
- assert incremental_state is not None
- self.encoder_attn._set_input_buffer(incremental_state, saved_state)
-
- x, attn = self.encoder_attn(
- query=x,
- key=encoder_out,
- value=encoder_out,
- key_padding_mask=encoder_padding_mask,
- incremental_state=incremental_state,
- static_kv=True,
- need_weights=need_attn or (not self.training and self.need_attn),
- need_head_weights=need_head_weights,
- )
- x = self.dropout_module(x)
- x = self.residual_connection(x, residual)
- if not self.normalize_before:
- x = self.encoder_attn_layer_norm(x)
-
- residual = x
- if self.normalize_before:
- x = self.final_layer_norm(x)
-
- x = self.activation_fn(self.fc1(x))
- x = self.activation_dropout_module(x)
- x = self.fc2(x)
- x = self.dropout_module(x)
- x = self.residual_connection(x, residual)
- if not self.normalize_before:
- x = self.final_layer_norm(x)
- if self.onnx_trace and incremental_state is not None:
- saved_state = self.self_attn._get_input_buffer(incremental_state)
- assert saved_state is not None
- if self_attn_padding_mask is not None:
- self_attn_state = [
- saved_state["prev_key"],
- saved_state["prev_value"],
- saved_state["prev_key_padding_mask"],
- ]
- else:
- self_attn_state = [saved_state["prev_key"], saved_state["prev_value"]]
- return x, attn, self_attn_state
- return x, attn, None
-
- def make_generation_fast_(self, need_attn: bool = False, **kwargs):
- self.need_attn = need_attn
-
-
-# backward compatible with the legacy argparse format
-class TransformerDecoderLayer(TransformerDecoderLayerBase):
- def __init__(
- self, args, no_encoder_attn=False, add_bias_kv=False, add_zero_attn=False
- ):
- super().__init__(
- TransformerConfig.from_namespace(args),
- no_encoder_attn=no_encoder_attn,
- add_bias_kv=add_bias_kv,
- add_zero_attn=add_zero_attn,
- )
- self.args = args
-
- def build_self_attention(
- self, embed_dim, args, add_bias_kv=False, add_zero_attn=False
- ):
- return super().build_self_attention(
- embed_dim,
- TransformerConfig.from_namespace(args),
- add_bias_kv=add_bias_kv,
- add_zero_attn=add_zero_attn,
- )
-
- def build_encoder_attention(self, embed_dim, args):
- return super().build_encoder_attention(
- embed_dim,
- TransformerConfig.from_namespace(args),
- )
diff --git a/spaces/ORI-Muchim/BarKeYaeTTS/text/__init__.py b/spaces/ORI-Muchim/BarKeYaeTTS/text/__init__.py
deleted file mode 100644
index 4e69c354dd24e3243980236eca962cd5945a92fc..0000000000000000000000000000000000000000
--- a/spaces/ORI-Muchim/BarKeYaeTTS/text/__init__.py
+++ /dev/null
@@ -1,32 +0,0 @@
-""" from https://github.com/keithito/tacotron """
-from text import cleaners
-
-
-def text_to_sequence(text, symbols, cleaner_names):
- '''Converts a string of text to a sequence of IDs corresponding to the symbols in the text.
- Args:
- text: string to convert to a sequence
- cleaner_names: names of the cleaner functions to run the text through
- Returns:
- List of integers corresponding to the symbols in the text
- '''
- _symbol_to_id = {s: i for i, s in enumerate(symbols)}
-
- sequence = []
-
- clean_text = _clean_text(text, cleaner_names)
- for symbol in clean_text:
- if symbol not in _symbol_to_id.keys():
- continue
- symbol_id = _symbol_to_id[symbol]
- sequence += [symbol_id]
- return sequence
-
-
-def _clean_text(text, cleaner_names):
- for name in cleaner_names:
- cleaner = getattr(cleaners, name)
- if not cleaner:
- raise Exception('Unknown cleaner: %s' % name)
- text = cleaner(text)
- return text
diff --git a/spaces/Omnibus/summarize-long-text/summarize.py b/spaces/Omnibus/summarize-long-text/summarize.py
deleted file mode 100644
index 35ee78e06538ac6826887be8dc0d5c9694760aaa..0000000000000000000000000000000000000000
--- a/spaces/Omnibus/summarize-long-text/summarize.py
+++ /dev/null
@@ -1,152 +0,0 @@
-import logging
-import pprint as pp
-
-from utils import validate_pytorch2
-
-logging.basicConfig(level=logging.INFO)
-import torch
-from tqdm.auto import tqdm
-from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
-
-
-def load_model_and_tokenizer(model_name: str) -> tuple:
- """
- load_model_and_tokenizer - load a model and tokenizer from a model name/ID on the hub
- :param str model_name: the model name/ID on the hub
- :return tuple: a tuple containing the model and tokenizer
- """
- logger = logging.getLogger(__name__)
- device = "cuda" if torch.cuda.is_available() else "cpu"
- model = AutoModelForSeq2SeqLM.from_pretrained(
- model_name,
- ).to(device)
- model = model.eval()
-
- tokenizer = AutoTokenizer.from_pretrained(model_name)
-
- logger.info(f"Loaded model {model_name} to {device}")
-
- if validate_pytorch2():
- try:
- logger.info("Compiling model with Torch 2.0")
- model = torch.compile(model)
- except Exception as e:
- logger.warning(f"Could not compile model with Torch 2.0: {e}")
- else:
- logger.info("Torch 2.0 not detected, skipping compilation")
-
- return model, tokenizer
-
-
-def summarize_and_score(ids, mask, model, tokenizer, **kwargs):
- """
- summarize_and_score - given a batch of ids and a mask, return a summary and a score for the summary
-
- Args:
- ids (): the batch of ids
- mask (): the attention mask for the batch
- model (): the model to use for summarization
- tokenizer (): the tokenizer to use for summarization
-
- Returns:
- str: the summary of the batch
- """
-
- ids = ids[None, :]
- mask = mask[None, :]
-
- input_ids = ids.to("cuda") if torch.cuda.is_available() else ids
- attention_mask = mask.to("cuda") if torch.cuda.is_available() else mask
-
- global_attention_mask = torch.zeros_like(attention_mask)
- # put global attention on token
- global_attention_mask[:, 0] = 1
-
- summary_pred_ids = model.generate(
- input_ids,
- attention_mask=attention_mask,
- global_attention_mask=global_attention_mask,
- output_scores=True,
- return_dict_in_generate=True,
- **kwargs,
- )
- summary = tokenizer.batch_decode(
- summary_pred_ids.sequences,
- skip_special_tokens=True,
- remove_invalid_values=True,
- )
- score = round(summary_pred_ids.sequences_scores.cpu().numpy()[0], 4)
-
- return summary, score
-
-
-def summarize_via_tokenbatches(
- input_text: str,
- model,
- tokenizer,
- batch_length=2048,
- batch_stride=16,
- min_batch_length: int = 512,
- **kwargs,
-):
- """
- summarize_via_tokenbatches - a function that takes a string and returns a summary
-
- Args:
- input_text (str): the text to summarize
- model (): the model to use for summarization
- tokenizer (): the tokenizer to use for summarization
- batch_length (int, optional): the length of each batch. Defaults to 2048.
- batch_stride (int, optional): the stride of each batch. Defaults to 16. The stride is the number of tokens that overlap between batches.
-
- Returns:
- str: the summary
- """
- # log all input parameters
- logger = logging.getLogger(__name__)
- # log all input parameters
- if batch_length < min_batch_length:
- logger.warning(
- f"batch_length must be at least {min_batch_length}. Setting batch_length to {min_batch_length}"
- )
- batch_length = min_batch_length
-
- logger.info(f"input parameters:\n{pp.pformat(kwargs)}")
- logger.info(f"batch_length: {batch_length}, batch_stride: {batch_stride}")
- encoded_input = tokenizer(
- input_text,
- padding="max_length",
- truncation=True,
- max_length=batch_length,
- stride=batch_stride,
- return_overflowing_tokens=True,
- add_special_tokens=False,
- return_tensors="pt",
- )
-
- in_id_arr, att_arr = encoded_input.input_ids, encoded_input.attention_mask
- gen_summaries = []
-
- pbar = tqdm(total=len(in_id_arr), desc="Summarizing")
-
- for _id, _mask in zip(in_id_arr, att_arr):
- result, score = summarize_and_score(
- ids=_id,
- mask=_mask,
- model=model,
- tokenizer=tokenizer,
- **kwargs,
- )
- score = round(float(score), 4)
- _sum = {
- "input_tokens": _id,
- "summary": result,
- "summary_score": score,
- }
- gen_summaries.append(_sum)
- logger.info(f"SCore {score} for summary:\n\t{result}")
- pbar.update()
-
- pbar.close()
- logger.debug(f"Generated summaries:\n{pp.pformat(gen_summaries)}")
- return gen_summaries
diff --git a/spaces/OpenGVLab/InternGPT/iGPT/models/grit_src/third_party/CenterNet2/detectron2/export/flatten.py b/spaces/OpenGVLab/InternGPT/iGPT/models/grit_src/third_party/CenterNet2/detectron2/export/flatten.py
deleted file mode 100644
index f5ba4297567d650f147eebeed361e9d62fab899d..0000000000000000000000000000000000000000
--- a/spaces/OpenGVLab/InternGPT/iGPT/models/grit_src/third_party/CenterNet2/detectron2/export/flatten.py
+++ /dev/null
@@ -1,330 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import collections
-from dataclasses import dataclass
-from typing import Callable, List, Optional, Tuple
-import torch
-from torch import nn
-
-from detectron2.structures import Boxes, Instances, ROIMasks
-from detectron2.utils.registry import _convert_target_to_string, locate
-
-from .torchscript_patch import patch_builtin_len
-
-
-@dataclass
-class Schema:
- """
- A Schema defines how to flatten a possibly hierarchical object into tuple of
- primitive objects, so it can be used as inputs/outputs of PyTorch's tracing.
-
- PyTorch does not support tracing a function that produces rich output
- structures (e.g. dict, Instances, Boxes). To trace such a function, we
- flatten the rich object into tuple of tensors, and return this tuple of tensors
- instead. Meanwhile, we also need to know how to "rebuild" the original object
- from the flattened results, so we can evaluate the flattened results.
- A Schema defines how to flatten an object, and while flattening it, it records
- necessary schemas so that the object can be rebuilt using the flattened outputs.
-
- The flattened object and the schema object is returned by ``.flatten`` classmethod.
- Then the original object can be rebuilt with the ``__call__`` method of schema.
-
- A Schema is a dataclass that can be serialized easily.
- """
-
- # inspired by FetchMapper in tensorflow/python/client/session.py
-
- @classmethod
- def flatten(cls, obj):
- raise NotImplementedError
-
- def __call__(self, values):
- raise NotImplementedError
-
- @staticmethod
- def _concat(values):
- ret = ()
- sizes = []
- for v in values:
- assert isinstance(v, tuple), "Flattened results must be a tuple"
- ret = ret + v
- sizes.append(len(v))
- return ret, sizes
-
- @staticmethod
- def _split(values, sizes):
- if len(sizes):
- expected_len = sum(sizes)
- assert (
- len(values) == expected_len
- ), f"Values has length {len(values)} but expect length {expected_len}."
- ret = []
- for k in range(len(sizes)):
- begin, end = sum(sizes[:k]), sum(sizes[: k + 1])
- ret.append(values[begin:end])
- return ret
-
-
-@dataclass
-class ListSchema(Schema):
- schemas: List[Schema] # the schemas that define how to flatten each element in the list
- sizes: List[int] # the flattened length of each element
-
- def __call__(self, values):
- values = self._split(values, self.sizes)
- if len(values) != len(self.schemas):
- raise ValueError(
- f"Values has length {len(values)} but schemas " f"has length {len(self.schemas)}!"
- )
- values = [m(v) for m, v in zip(self.schemas, values)]
- return list(values)
-
- @classmethod
- def flatten(cls, obj):
- res = [flatten_to_tuple(k) for k in obj]
- values, sizes = cls._concat([k[0] for k in res])
- return values, cls([k[1] for k in res], sizes)
-
-
-@dataclass
-class TupleSchema(ListSchema):
- def __call__(self, values):
- return tuple(super().__call__(values))
-
-
-@dataclass
-class IdentitySchema(Schema):
- def __call__(self, values):
- return values[0]
-
- @classmethod
- def flatten(cls, obj):
- return (obj,), cls()
-
-
-@dataclass
-class DictSchema(ListSchema):
- keys: List[str]
-
- def __call__(self, values):
- values = super().__call__(values)
- return dict(zip(self.keys, values))
-
- @classmethod
- def flatten(cls, obj):
- for k in obj.keys():
- if not isinstance(k, str):
- raise KeyError("Only support flattening dictionaries if keys are str.")
- keys = sorted(obj.keys())
- values = [obj[k] for k in keys]
- ret, schema = ListSchema.flatten(values)
- return ret, cls(schema.schemas, schema.sizes, keys)
-
-
-@dataclass
-class InstancesSchema(DictSchema):
- def __call__(self, values):
- image_size, fields = values[-1], values[:-1]
- fields = super().__call__(fields)
- return Instances(image_size, **fields)
-
- @classmethod
- def flatten(cls, obj):
- ret, schema = super().flatten(obj.get_fields())
- size = obj.image_size
- if not isinstance(size, torch.Tensor):
- size = torch.tensor(size)
- return ret + (size,), schema
-
-
-@dataclass
-class TensorWrapSchema(Schema):
- """
- For classes that are simple wrapper of tensors, e.g.
- Boxes, RotatedBoxes, BitMasks
- """
-
- class_name: str
-
- def __call__(self, values):
- return locate(self.class_name)(values[0])
-
- @classmethod
- def flatten(cls, obj):
- return (obj.tensor,), cls(_convert_target_to_string(type(obj)))
-
-
-# if more custom structures needed in the future, can allow
-# passing in extra schemas for custom types
-def flatten_to_tuple(obj):
- """
- Flatten an object so it can be used for PyTorch tracing.
- Also returns how to rebuild the original object from the flattened outputs.
-
- Returns:
- res (tuple): the flattened results that can be used as tracing outputs
- schema: an object with a ``__call__`` method such that ``schema(res) == obj``.
- It is a pure dataclass that can be serialized.
- """
- schemas = [
- ((str, bytes), IdentitySchema),
- (list, ListSchema),
- (tuple, TupleSchema),
- (collections.abc.Mapping, DictSchema),
- (Instances, InstancesSchema),
- ((Boxes, ROIMasks), TensorWrapSchema),
- ]
- for klass, schema in schemas:
- if isinstance(obj, klass):
- F = schema
- break
- else:
- F = IdentitySchema
-
- return F.flatten(obj)
-
-
-class TracingAdapter(nn.Module):
- """
- A model may take rich input/output format (e.g. dict or custom classes),
- but `torch.jit.trace` requires tuple of tensors as input/output.
- This adapter flattens input/output format of a model so it becomes traceable.
-
- It also records the necessary schema to rebuild model's inputs/outputs from flattened
- inputs/outputs.
-
- Example:
- ::
- outputs = model(inputs) # inputs/outputs may be rich structure
- adapter = TracingAdapter(model, inputs)
-
- # can now trace the model, with adapter.flattened_inputs, or another
- # tuple of tensors with the same length and meaning
- traced = torch.jit.trace(adapter, adapter.flattened_inputs)
-
- # traced model can only produce flattened outputs (tuple of tensors)
- flattened_outputs = traced(*adapter.flattened_inputs)
- # adapter knows the schema to convert it back (new_outputs == outputs)
- new_outputs = adapter.outputs_schema(flattened_outputs)
- """
-
- flattened_inputs: Tuple[torch.Tensor] = None
- """
- Flattened version of inputs given to this class's constructor.
- """
-
- inputs_schema: Schema = None
- """
- Schema of the inputs given to this class's constructor.
- """
-
- outputs_schema: Schema = None
- """
- Schema of the output produced by calling the given model with inputs.
- """
-
- def __init__(
- self,
- model: nn.Module,
- inputs,
- inference_func: Optional[Callable] = None,
- allow_non_tensor: bool = False,
- ):
- """
- Args:
- model: an nn.Module
- inputs: An input argument or a tuple of input arguments used to call model.
- After flattening, it has to only consist of tensors.
- inference_func: a callable that takes (model, *inputs), calls the
- model with inputs, and return outputs. By default it
- is ``lambda model, *inputs: model(*inputs)``. Can be override
- if you need to call the model differently.
- allow_non_tensor: allow inputs/outputs to contain non-tensor objects.
- This option will filter out non-tensor objects to make the
- model traceable, but ``inputs_schema``/``outputs_schema`` cannot be
- used anymore because inputs/outputs cannot be rebuilt from pure tensors.
- This is useful when you're only interested in the single trace of
- execution (e.g. for flop count), but not interested in
- generalizing the traced graph to new inputs.
- """
- super().__init__()
- if isinstance(model, (nn.parallel.distributed.DistributedDataParallel, nn.DataParallel)):
- model = model.module
- self.model = model
- if not isinstance(inputs, tuple):
- inputs = (inputs,)
- self.inputs = inputs
- self.allow_non_tensor = allow_non_tensor
-
- if inference_func is None:
- inference_func = lambda model, *inputs: model(*inputs) # noqa
- self.inference_func = inference_func
-
- self.flattened_inputs, self.inputs_schema = flatten_to_tuple(inputs)
-
- if all(isinstance(x, torch.Tensor) for x in self.flattened_inputs):
- return
- if self.allow_non_tensor:
- self.flattened_inputs = tuple(
- [x for x in self.flattened_inputs if isinstance(x, torch.Tensor)]
- )
- self.inputs_schema = None
- else:
- for input in self.flattened_inputs:
- if not isinstance(input, torch.Tensor):
- raise ValueError(
- "Inputs for tracing must only contain tensors. "
- f"Got a {type(input)} instead."
- )
-
- def forward(self, *args: torch.Tensor):
- with torch.no_grad(), patch_builtin_len():
- if self.inputs_schema is not None:
- inputs_orig_format = self.inputs_schema(args)
- else:
- if len(args) != len(self.flattened_inputs) or any(
- x is not y for x, y in zip(args, self.flattened_inputs)
- ):
- raise ValueError(
- "TracingAdapter does not contain valid inputs_schema."
- " So it cannot generalize to other inputs and must be"
- " traced with `.flattened_inputs`."
- )
- inputs_orig_format = self.inputs
-
- outputs = self.inference_func(self.model, *inputs_orig_format)
- flattened_outputs, schema = flatten_to_tuple(outputs)
-
- flattened_output_tensors = tuple(
- [x for x in flattened_outputs if isinstance(x, torch.Tensor)]
- )
- if len(flattened_output_tensors) < len(flattened_outputs):
- if self.allow_non_tensor:
- flattened_outputs = flattened_output_tensors
- self.outputs_schema = None
- else:
- raise ValueError(
- "Model cannot be traced because some model outputs "
- "cannot flatten to tensors."
- )
- else: # schema is valid
- if self.outputs_schema is None:
- self.outputs_schema = schema
- else:
- assert self.outputs_schema == schema, (
- "Model should always return outputs with the same "
- "structure so it can be traced!"
- )
- return flattened_outputs
-
- def _create_wrapper(self, traced_model):
- """
- Return a function that has an input/output interface the same as the
- original model, but it calls the given traced model under the hood.
- """
-
- def forward(*args):
- flattened_inputs, _ = flatten_to_tuple(args)
- flattened_outputs = traced_model(*flattened_inputs)
- return self.outputs_schema(flattened_outputs)
-
- return forward
diff --git a/spaces/OptimalScale/Robin-33b/lmflow/datasets/dataset.py b/spaces/OptimalScale/Robin-33b/lmflow/datasets/dataset.py
deleted file mode 100644
index 8228d20ab4165515c2d1d09ae679473a53dbb6ed..0000000000000000000000000000000000000000
--- a/spaces/OptimalScale/Robin-33b/lmflow/datasets/dataset.py
+++ /dev/null
@@ -1,308 +0,0 @@
-#!/usr/bin/env python
-# coding=utf-8
-"""This Python code defines a class Dataset with methods for initializing, loading,
-and manipulating datasets from different backends such as Hugging Face and JSON.
-
-The `Dataset` class includes methods for loading datasets from a dictionary and a Hugging
-Face dataset, mapping datasets, and retrieving the backend dataset and arguments.
-"""
-
-
-
-# Importing necessary libraries and modules
-import json
-from pathlib import Path
-from typing import Optional
-
-from datasets import load_dataset
-from datasets import Dataset as HFDataset
-
-from lmflow.args import DatasetArguments
-
-DATASET_TYPES = [
- "text_only",
- "text2text",
-]
-
-KEY_TYPE = "type"
-KEY_INSTANCES = "instances"
-
-class Dataset:
- r"""
- Initializes the Dataset object with the given parameters.
-
- Parameters
- ------------
- data_args : DatasetArguments object.
- Contains the arguments required to load the dataset.
-
- backend : str, default="huggingface"
- A string representing the dataset backend. Defaults to "huggingface".
-
- args : Optional.
- Positional arguments.
-
- kwargs : Optional.
- Keyword arguments.
- """
- def __init__(self, data_args=None, backend: str="huggingface", *args, **kwargs):
- self.data_args = data_args
- self.backend = backend
- self.backend_dataset = None
- self.type = None # Original type of the dataset
- self.dataset_path = data_args.dataset_path
-
- if data_args.dataset_path is None:
- return
-
- if backend == "huggingface":
- data_files = [
- x.absolute().as_posix()
- for x in Path(self.dataset_path).glob("*.json")
- ]
-
- # Iterate through all the files and ensure they have the same data type
- for single_file in data_files:
- with open(single_file) as fin:
- json_data = json.load(fin)
- if KEY_TYPE not in json_data.keys():
- raise ValueError(
- f'"{KEY_TYPE}" field must be specified for data, e.g.'
- '{\n'
- f' "{KEY_TYPE}: "text_only",\n'
- f' "{KEY_INSTANCES}": [\n'
- ' { "text": "Sentence 1: This is a sentence." }\n'
- ' { "text": "Sentence 2: This is another sentence." }\n'
- f' ]\n'
- '}'
- )
-
- if self.type is None:
- self.type = json_data[KEY_TYPE]
- elif self.type != json_data[KEY_TYPE]:
- raise ValueError(
- 'All task files must have same data types. Previous'
- f' files have type "{self.type}", but in file'
- f' {single_file}, it has type "{self.type}".'
- )
-
- # Load the dataset using the HuggingFace dataset library
- extensions = "json"
- raw_dataset = load_dataset(
- extensions,
- data_files=data_files,
- field=KEY_INSTANCES,
- split="train",
- use_auth_token=None,
- )
- self.backend_dataset = raw_dataset
- elif backend == "json":
- # TODO (@Jiachun)
- pass
- else:
- raise NotImplementedError(f'Unsupported dataset backend "{backend}"')
-
-
- def _check_data_type(self):
- # TODO: check if data type and data structure matches, raise messages
- # with hints
- pass
-
-
- def from_dict(self, dict_obj: dict, *args, **kwargs):
- r"""
- Create a Dataset object from a dictionary.
-
- Return a Dataset given a dict with format:
- {
- "type": TYPE,
- "instances": [
- {
- "key_1": VALUE_1.1,
- "key_2": VALUE_1.2,
- ...
- },
- {
- "key_1": VALUE_2.1,
- "key_2": VALUE_2.2,
- ...
- },
- ...
- ]
- }
-
- Parameters
- -----------
-
- dict_obj : dict.
- A dictionary containing the dataset information.
-
- args : Optional.
- Positional arguments.
-
- kwargs : Optional.
- Keyword arguments.
-
- Returns
- ---------
-
- self : Dataset object.
- """
- if self.backend == "huggingface":
- if KEY_TYPE not in dict_obj:
- raise ValueError(
- f'"{KEY_TYPE}" must be provided to initialize a dataset'
- )
- if KEY_INSTANCES not in dict_obj:
- raise ValueError(
- f'"{KEY_INSTANCES}" must be provided to initialize a dataset'
- )
-
- self.type = dict_obj[KEY_TYPE]
-
- hf_dict = {}
- if len(dict_obj[KEY_INSTANCES]) > 0:
- for key in dict_obj[KEY_INSTANCES][0].keys():
- hf_dict[key] = [ instance[key] for instance in dict_obj[KEY_INSTANCES] ]
-
- self.backend_dataset = HFDataset.from_dict(hf_dict, *args, **kwargs)
- return self
- else:
- raise NotImplementedError(
- f'Currently .from_dict is not supported for backend "{backend}"'
- )
-
-
- @classmethod
- def create_from_dict(cls, dict_obj, *args, **kwargs):
- r"""
- Returns
- --------
-
- Returns a Dataset object given a dict.
- """
- empty_data_args = DatasetArguments(dataset_path=None)
- dataset = Dataset(empty_data_args)
- return dataset.from_dict(dict_obj)
-
-
- def to_dict(self):
- r"""
- Returns
- ---------
-
- Return a dict represents the dataset:
- {
- "type": TYPE,
- "instances": [
- {
- "key_1": VALUE_1.1,
- "key_2": VALUE_1.2,
- ...
- },
- {
- "key_1": VALUE_2.1,
- "key_2": VALUE_2.2,
- ...
- },
- ...
- ]
- }
-
- A python dict object represents the content of this dataset.
- """
- if self.backend == "huggingface":
- dict_obj = {}
- dict_obj[KEY_TYPE] = self.get_type()
-
- hf_dict = self.backend_dataset.to_dict()
- dict_obj[KEY_INSTANCES] = []
-
- first_key = None
- for key in hf_dict.keys():
- first_key = key
- break
-
- if first_key is not None:
- num_instances = len(hf_dict[first_key])
- dict_obj[KEY_INSTANCES] = [
- {
- key: hf_dict[key][i] for key in hf_dict.keys()
- }
- for i in range(num_instances)
- ]
-
- return dict_obj
- else:
- raise NotImplementedError(
- f'Current .to_dict is not supported for backend "{backend}"'
- )
-
-
- def map(self, *args, **kwargs):
- r"""
- Parameters
- ------------
- args : Optional.
- Positional arguments.
-
- kwargs : Optional.
- Keyword arguments.
-
- Returns
- ---------
-
- self : Dataset object.
- """
- # If the dataset uses Hugging Face as the backend,
- # call the `map()` function of the Hugging Face backend dataset
- if self.backend == "huggingface":
- # Set the mapped dataset as the backend dataset of the current dataset
- mapped_backend_dataset = self.backend_dataset.map(*args, **kwargs)
- self.backend_dataset = mapped_backend_dataset
- return self
- else:
- # If the backend is not Hugging Face, raise a NotImplementedError
- raise NotImplementedError(
- f'Currently .map is not supported for backend "{backend}"'
- )
-
-
- def get_backend(self) -> Optional[str]:
- r"""
- Returns
- ---------
-
- self.backend
- """
- return self.backend
-
-
- def get_backend_dataset(self):
- r"""
- Returns
- ---------
-
- self.backend_dataset
- """
- return self.backend_dataset
-
-
- def get_data_args(self):
- r"""
- Returns
- ---------
-
- self.data_args
- """
- return self.data_args
-
-
- def get_type(self):
- r"""
- Returns
- ---------
-
- self.type
- """
- return self.type
diff --git a/spaces/Osborn-bh/ChatGLM3-6B-Osborn/composite_demo/conversation.py b/spaces/Osborn-bh/ChatGLM3-6B-Osborn/composite_demo/conversation.py
deleted file mode 100644
index 1ac13e774775dfad8e18e728e8b33ca2a40b8f65..0000000000000000000000000000000000000000
--- a/spaces/Osborn-bh/ChatGLM3-6B-Osborn/composite_demo/conversation.py
+++ /dev/null
@@ -1,119 +0,0 @@
-from dataclasses import dataclass
-from enum import auto, Enum
-import json
-
-from PIL.Image import Image
-import streamlit as st
-from streamlit.delta_generator import DeltaGenerator
-
-TOOL_PROMPT = 'Answer the following questions as best as you can. You have access to the following tools:\n'
-
-class Role(Enum):
- SYSTEM = auto()
- USER = auto()
- ASSISTANT = auto()
- TOOL = auto()
- INTERPRETER = auto()
- OBSERVATION = auto()
-
- def __str__(self):
- match self:
- case Role.SYSTEM:
- return "<|system|>"
- case Role.USER:
- return "<|user|>"
- case Role.ASSISTANT | Role.TOOL | Role.INTERPRETER:
- return "<|assistant|>"
- case Role.OBSERVATION:
- return "<|observation|>"
-
- # Get the message block for the given role
- def get_message(self):
- # Compare by value here, because the enum object in the session state
- # is not the same as the enum cases here, due to streamlit's rerunning
- # behavior.
- match self.value:
- case Role.SYSTEM.value:
- return
- case Role.USER.value:
- return st.chat_message(name="user", avatar="user")
- case Role.ASSISTANT.value:
- return st.chat_message(name="assistant", avatar="assistant")
- case Role.TOOL.value:
- return st.chat_message(name="tool", avatar="assistant")
- case Role.INTERPRETER.value:
- return st.chat_message(name="interpreter", avatar="assistant")
- case Role.OBSERVATION.value:
- return st.chat_message(name="observation", avatar="user")
- case _:
- st.error(f'Unexpected role: {self}')
-
-@dataclass
-class Conversation:
- role: Role
- content: str
- tool: str | None = None
- image: Image | None = None
-
- def __str__(self) -> str:
- print(self.role, self.content, self.tool)
- match self.role:
- case Role.SYSTEM | Role.USER | Role.ASSISTANT | Role.OBSERVATION:
- return f'{self.role}\n{self.content}'
- case Role.TOOL:
- return f'{self.role}{self.tool}\n{self.content}'
- case Role.INTERPRETER:
- return f'{self.role}interpreter\n{self.content}'
-
- # Human readable format
- def get_text(self) -> str:
- text = postprocess_text(self.content)
- match self.role.value:
- case Role.TOOL.value:
- text = f'Calling tool `{self.tool}`:\n{text}'
- case Role.INTERPRETER.value:
- text = f'{text}'
- case Role.OBSERVATION.value:
- text = f'Observation:\n```\n{text}\n```'
- return text
-
- # Display as a markdown block
- def show(self, placeholder: DeltaGenerator | None=None) -> str:
- if placeholder:
- message = placeholder
- else:
- message = self.role.get_message()
- if self.image:
- message.image(self.image)
- else:
- text = self.get_text()
- message.markdown(text)
-
-def preprocess_text(
- system: str | None,
- tools: list[dict] | None,
- history: list[Conversation],
-) -> str:
- if tools:
- tools = json.dumps(tools, indent=4, ensure_ascii=False)
-
- prompt = f"{Role.SYSTEM}\n"
- prompt += system if not tools else TOOL_PROMPT
- if tools:
- tools = json.loads(tools)
- prompt += json.dumps(tools, ensure_ascii=False)
- for conversation in history:
- prompt += f'{conversation}'
- prompt += f'{Role.ASSISTANT}\n'
- return prompt
-
-def postprocess_text(text: str) -> str:
- text = text.replace("\(", "$")
- text = text.replace("\)", "$")
- text = text.replace("\[", "$$")
- text = text.replace("\]", "$$")
- text = text.replace("<|assistant|>", "")
- text = text.replace("<|observation|>", "")
- text = text.replace("<|system|>", "")
- text = text.replace("<|user|>", "")
- return text.strip()
\ No newline at end of file
diff --git a/spaces/Oumar199/Fake-Real-Face-Detection/fake_face_detection/data/__init__.py b/spaces/Oumar199/Fake-Real-Face-Detection/fake_face_detection/data/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/PAIR/PAIR-Diffusion/annotator/OneFormer/oneformer/modeling/backbone/__init__.py b/spaces/PAIR/PAIR-Diffusion/annotator/OneFormer/oneformer/modeling/backbone/__init__.py
deleted file mode 100644
index 9020c2df23e2af280b7bb168b996ae9eaf312eb8..0000000000000000000000000000000000000000
--- a/spaces/PAIR/PAIR-Diffusion/annotator/OneFormer/oneformer/modeling/backbone/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
diff --git a/spaces/PAIR/PAIR-Diffusion/annotator/OneFormer/oneformer/oneformer_model.py b/spaces/PAIR/PAIR-Diffusion/annotator/OneFormer/oneformer/oneformer_model.py
deleted file mode 100644
index 01508df74cfe8a722dd937b7f54b12296258c5a1..0000000000000000000000000000000000000000
--- a/spaces/PAIR/PAIR-Diffusion/annotator/OneFormer/oneformer/oneformer_model.py
+++ /dev/null
@@ -1,486 +0,0 @@
-# ------------------------------------------------------------------------------
-# Reference: https://github.com/facebookresearch/Mask2Former/blob/main/mask2former/maskformer_model.py
-# Modified by Jitesh Jain (https://github.com/praeclarumjj3)
-# ------------------------------------------------------------------------------
-
-from typing import Tuple
-
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from detectron2.config import configurable
-from detectron2.data import MetadataCatalog
-from detectron2.modeling import META_ARCH_REGISTRY, build_backbone, build_sem_seg_head
-from detectron2.modeling.backbone import Backbone
-from detectron2.modeling.postprocessing import sem_seg_postprocess
-from detectron2.structures import Boxes, ImageList, Instances, BitMasks
-from detectron2.utils.memory import retry_if_cuda_oom
-
-from .modeling.criterion import SetCriterion
-from .modeling.matcher import HungarianMatcher
-from einops import rearrange
-from .modeling.transformer_decoder.text_transformer import TextTransformer
-from .modeling.transformer_decoder.oneformer_transformer_decoder import MLP
-from oneformer.data.tokenizer import SimpleTokenizer, Tokenize
-
-@META_ARCH_REGISTRY.register()
-class OneFormer(nn.Module):
- """
- Main class for mask classification semantic segmentation architectures.
- """
-
- @configurable
- def __init__(
- self,
- *,
- backbone: Backbone,
- sem_seg_head: nn.Module,
- task_mlp: nn.Module,
- text_encoder: nn.Module,
- text_projector: nn.Module,
- criterion: nn.Module,
- prompt_ctx: nn.Embedding,
- num_queries: int,
- object_mask_threshold: float,
- overlap_threshold: float,
- metadata,
- size_divisibility: int,
- sem_seg_postprocess_before_inference: bool,
- pixel_mean: Tuple[float],
- pixel_std: Tuple[float],
- # inference
- semantic_on: bool,
- panoptic_on: bool,
- instance_on: bool,
- detection_on: bool,
- test_topk_per_image: int,
- task_seq_len: int,
- max_seq_len: int,
- is_demo: bool,
- ):
- """
- Args:
- backbone: a backbone module, must follow detectron2's backbone interface
- sem_seg_head: a module that predicts semantic segmentation from backbone features
- criterion: a module that defines the loss
- num_queries: int, number of queries
- object_mask_threshold: float, threshold to filter query based on classification score
- for panoptic segmentation inference
- overlap_threshold: overlap threshold used in general inference for panoptic segmentation
- metadata: dataset meta, get `thing` and `stuff` category names for panoptic
- segmentation inference
- size_divisibility: Some backbones require the input height and width to be divisible by a
- specific integer. We can use this to override such requirement.
- sem_seg_postprocess_before_inference: whether to resize the prediction back
- to original input size before semantic segmentation inference or after.
- For high-resolution dataset like Mapillary, resizing predictions before
- inference will cause OOM error.
- pixel_mean, pixel_std: list or tuple with #channels element, representing
- the per-channel mean and std to be used to normalize the input image
- semantic_on: bool, whether to output semantic segmentation prediction
- instance_on: bool, whether to output instance segmentation prediction
- panoptic_on: bool, whether to output panoptic segmentation prediction
- test_topk_per_image: int, instance segmentation parameter, keep topk instances per image
- """
- super().__init__()
- self.backbone = backbone
- self.sem_seg_head = sem_seg_head
- self.task_mlp = task_mlp
- self.text_encoder = text_encoder
- self.text_projector = text_projector
- self.prompt_ctx = prompt_ctx
- self.criterion = criterion
- self.num_queries = num_queries
- self.overlap_threshold = overlap_threshold
- self.object_mask_threshold = object_mask_threshold
- self.metadata = metadata
- if size_divisibility < 0:
- # use backbone size_divisibility if not set
- size_divisibility = self.backbone.size_divisibility
- self.size_divisibility = size_divisibility
- self.sem_seg_postprocess_before_inference = sem_seg_postprocess_before_inference
- self.register_buffer("pixel_mean", torch.Tensor(pixel_mean).view(-1, 1, 1), False)
- self.register_buffer("pixel_std", torch.Tensor(pixel_std).view(-1, 1, 1), False)
-
- # additional args
- self.semantic_on = semantic_on
- self.instance_on = instance_on
- self.panoptic_on = panoptic_on
- self.detection_on = detection_on
- self.test_topk_per_image = test_topk_per_image
-
- self.text_tokenizer = Tokenize(SimpleTokenizer(), max_seq_len=max_seq_len)
- self.task_tokenizer = Tokenize(SimpleTokenizer(), max_seq_len=task_seq_len)
- self.is_demo = is_demo
-
- self.thing_indices = [k for k in self.metadata.thing_dataset_id_to_contiguous_id.keys()]
-
- if not self.semantic_on:
- assert self.sem_seg_postprocess_before_inference
-
- @classmethod
- def from_config(cls, cfg):
- backbone = build_backbone(cfg)
- sem_seg_head = build_sem_seg_head(cfg, backbone.output_shape())
-
- if cfg.MODEL.IS_TRAIN:
- text_encoder = TextTransformer(context_length=cfg.MODEL.TEXT_ENCODER.CONTEXT_LENGTH,
- width=cfg.MODEL.TEXT_ENCODER.WIDTH,
- layers=cfg.MODEL.TEXT_ENCODER.NUM_LAYERS,
- vocab_size=cfg.MODEL.TEXT_ENCODER.VOCAB_SIZE)
- text_projector = MLP(text_encoder.width, cfg.MODEL.ONE_FORMER.HIDDEN_DIM,
- cfg.MODEL.ONE_FORMER.HIDDEN_DIM, cfg.MODEL.TEXT_ENCODER.PROJ_NUM_LAYERS)
- if cfg.MODEL.TEXT_ENCODER.N_CTX > 0:
- prompt_ctx = nn.Embedding(cfg.MODEL.TEXT_ENCODER.N_CTX, cfg.MODEL.TEXT_ENCODER.WIDTH)
- else:
- prompt_ctx = None
- else:
- text_encoder = None
- text_projector = None
- prompt_ctx = None
-
- task_mlp = MLP(cfg.INPUT.TASK_SEQ_LEN, cfg.MODEL.ONE_FORMER.HIDDEN_DIM,
- cfg.MODEL.ONE_FORMER.HIDDEN_DIM, 2)
-
- # Loss parameters:
- deep_supervision = cfg.MODEL.ONE_FORMER.DEEP_SUPERVISION
- no_object_weight = cfg.MODEL.ONE_FORMER.NO_OBJECT_WEIGHT
-
- # loss weights
- class_weight = cfg.MODEL.ONE_FORMER.CLASS_WEIGHT
- dice_weight = cfg.MODEL.ONE_FORMER.DICE_WEIGHT
- mask_weight = cfg.MODEL.ONE_FORMER.MASK_WEIGHT
- contrastive_weight = cfg.MODEL.ONE_FORMER.CONTRASTIVE_WEIGHT
-
- # building criterion
- matcher = HungarianMatcher(
- cost_class=class_weight,
- cost_mask=mask_weight,
- cost_dice=dice_weight,
- num_points=cfg.MODEL.ONE_FORMER.TRAIN_NUM_POINTS,
- )
-
- weight_dict = {"loss_ce": class_weight, "loss_mask": mask_weight,
- "loss_dice": dice_weight, "loss_contrastive": contrastive_weight}
-
-
- if deep_supervision:
- dec_layers = cfg.MODEL.ONE_FORMER.DEC_LAYERS
- aux_weight_dict = {}
- for i in range(dec_layers - 1):
- aux_weight_dict.update({k + f"_{i}": v for k, v in weight_dict.items()})
- weight_dict.update(aux_weight_dict)
-
- losses = ["labels", "masks", "contrastive"]
-
- criterion = SetCriterion(
- sem_seg_head.num_classes,
- matcher=matcher,
- weight_dict=weight_dict,
- eos_coef=no_object_weight,
- contrast_temperature=cfg.MODEL.ONE_FORMER.CONTRASTIVE_TEMPERATURE,
- losses=losses,
- num_points=cfg.MODEL.ONE_FORMER.TRAIN_NUM_POINTS,
- oversample_ratio=cfg.MODEL.ONE_FORMER.OVERSAMPLE_RATIO,
- importance_sample_ratio=cfg.MODEL.ONE_FORMER.IMPORTANCE_SAMPLE_RATIO,
- )
-
- return {
- "backbone": backbone,
- "sem_seg_head": sem_seg_head,
- "task_mlp": task_mlp,
- "prompt_ctx": prompt_ctx,
- "text_encoder": text_encoder,
- "text_projector": text_projector,
- "criterion": criterion,
- "num_queries": cfg.MODEL.ONE_FORMER.NUM_OBJECT_QUERIES,
- "object_mask_threshold": cfg.MODEL.TEST.OBJECT_MASK_THRESHOLD,
- "overlap_threshold": cfg.MODEL.TEST.OVERLAP_THRESHOLD,
- "metadata": MetadataCatalog.get(cfg.DATASETS.TRAIN[0]),
- "size_divisibility": cfg.MODEL.ONE_FORMER.SIZE_DIVISIBILITY,
- "sem_seg_postprocess_before_inference": (
- cfg.MODEL.TEST.SEM_SEG_POSTPROCESSING_BEFORE_INFERENCE
- or cfg.MODEL.TEST.PANOPTIC_ON
- or cfg.MODEL.TEST.INSTANCE_ON
- ),
- "pixel_mean": cfg.MODEL.PIXEL_MEAN,
- "pixel_std": cfg.MODEL.PIXEL_STD,
- # inference
- "semantic_on": cfg.MODEL.TEST.SEMANTIC_ON,
- "instance_on": cfg.MODEL.TEST.INSTANCE_ON,
- "panoptic_on": cfg.MODEL.TEST.PANOPTIC_ON,
- "detection_on": cfg.MODEL.TEST.DETECTION_ON,
- "test_topk_per_image": cfg.TEST.DETECTIONS_PER_IMAGE,
- "task_seq_len": cfg.INPUT.TASK_SEQ_LEN,
- "max_seq_len": cfg.INPUT.MAX_SEQ_LEN,
- "is_demo": cfg.MODEL.IS_DEMO,
- }
-
- @property
- def device(self):
- return self.pixel_mean.device
-
- def encode_text(self, text):
- assert text.ndim in [2, 3], text.ndim
- b = text.shape[0]
- squeeze_dim = False
- num_text = 1
- if text.ndim == 3:
- num_text = text.shape[1]
- text = rearrange(text, 'b n l -> (b n) l', n=num_text)
- squeeze_dim = True
-
- # [B, C]
- x = self.text_encoder(text)
-
- text_x = self.text_projector(x)
-
- if squeeze_dim:
- text_x = rearrange(text_x, '(b n) c -> b n c', n=num_text)
- if self.prompt_ctx is not None:
- text_ctx = self.prompt_ctx.weight.unsqueeze(0).repeat(text_x.shape[0], 1, 1)
- text_x = torch.cat([text_x, text_ctx], dim=1)
-
- return {"texts": text_x}
-
- def forward(self, batched_inputs):
- """
- Args:
- batched_inputs: a list, batched outputs of :class:`DatasetMapper`.
- Each item in the list contains the inputs for one image.
- For now, each item in the list is a dict that contains:
- * "image": Tensor, image in (C, H, W) format.
- * "instances": per-region ground truth
- * Other information that's included in the original dicts, such as:
- "height", "width" (int): the output resolution of the model (may be different
- from input resolution), used in inference.
- Returns:
- list[dict]:
- each dict has the results for one image. The dict contains the following keys:
- * "sem_seg":
- A Tensor that represents the
- per-pixel segmentation prediced by the head.
- The prediction has shape KxHxW that represents the logits of
- each class for each pixel.
- * "panoptic_seg":
- A tuple that represent panoptic output
- panoptic_seg (Tensor): of shape (height, width) where the values are ids for each segment.
- segments_info (list[dict]): Describe each segment in `panoptic_seg`.
- Each dict contains keys "id", "category_id", "isthing".
- """
- images = [x["image"].to(self.device) for x in batched_inputs]
- images = [(x - self.pixel_mean) / self.pixel_std for x in images]
- images = ImageList.from_tensors(images, self.size_divisibility)
-
- tasks = torch.cat([self.task_tokenizer(x["task"]).to(self.device).unsqueeze(0) for x in batched_inputs], dim=0)
- tasks = self.task_mlp(tasks.float())
-
- features = self.backbone(images.tensor)
- outputs = self.sem_seg_head(features, tasks)
-
- if self.training:
- texts = torch.cat([self.text_tokenizer(x["text"]).to(self.device).unsqueeze(0) for x in batched_inputs], dim=0)
- texts_x = self.encode_text(texts)
-
- outputs = {**outputs, **texts_x}
-
- # mask classification target
- if "instances" in batched_inputs[0]:
- gt_instances = [x["instances"].to(self.device) for x in batched_inputs]
- targets = self.prepare_targets(gt_instances, images)
- else:
- targets = None
-
- # bipartite matching-based loss
- losses = self.criterion(outputs, targets)
-
- for k in list(losses.keys()):
- if k in self.criterion.weight_dict:
- losses[k] *= self.criterion.weight_dict[k]
- else:
- # remove this loss if not specified in `weight_dict`
- losses.pop(k)
- return losses
- else:
- mask_cls_results = outputs["pred_logits"]
- mask_pred_results = outputs["pred_masks"]
- # upsample masks
- mask_pred_results = F.interpolate(
- mask_pred_results,
- size=(images.tensor.shape[-2], images.tensor.shape[-1]),
- mode="bilinear",
- align_corners=False,
- )
-
- del outputs
-
- processed_results = []
- for i, data in enumerate(zip(
- mask_cls_results, mask_pred_results, batched_inputs, images.image_sizes
- )):
- mask_cls_result, mask_pred_result, input_per_image, image_size = data
- height = input_per_image.get("height", image_size[0])
- width = input_per_image.get("width", image_size[1])
- processed_results.append({})
-
- if self.sem_seg_postprocess_before_inference:
- mask_pred_result = retry_if_cuda_oom(sem_seg_postprocess)(
- mask_pred_result, image_size, height, width
- )
- mask_cls_result = mask_cls_result.to(mask_pred_result)
-
- # semantic segmentation inference
- if self.semantic_on:
- r = retry_if_cuda_oom(self.semantic_inference)(mask_cls_result, mask_pred_result)
- if not self.sem_seg_postprocess_before_inference:
- r = retry_if_cuda_oom(sem_seg_postprocess)(r, image_size, height, width)
- processed_results[-1]["sem_seg"] = r
-
- # panoptic segmentation inference
- if self.panoptic_on:
- panoptic_r = retry_if_cuda_oom(self.panoptic_inference)(mask_cls_result, mask_pred_result)
- processed_results[-1]["panoptic_seg"] = panoptic_r
-
- # instance segmentation inference
- if self.instance_on:
- instance_r = retry_if_cuda_oom(self.instance_inference)(mask_cls_result, mask_pred_result, input_per_image["task"])
- processed_results[-1]["instances"] = instance_r
-
- if self.detection_on:
- bbox_r = retry_if_cuda_oom(self.instance_inference)(mask_cls_result, mask_pred_result, input_per_image["task"])
- processed_results[-1]["box_instances"] = bbox_r
-
- return processed_results
-
- def prepare_targets(self, targets, images):
- h_pad, w_pad = images.tensor.shape[-2:]
- new_targets = []
- for targets_per_image in targets:
- # pad gt
- gt_masks = targets_per_image.gt_masks
- padded_masks = torch.zeros((gt_masks.shape[0], h_pad, w_pad), dtype=gt_masks.dtype, device=gt_masks.device)
- padded_masks[:, : gt_masks.shape[1], : gt_masks.shape[2]] = gt_masks
- new_targets.append(
- {
- "labels": targets_per_image.gt_classes,
- "masks": padded_masks,
- }
- )
- return new_targets
-
- def semantic_inference(self, mask_cls, mask_pred):
- mask_cls = F.softmax(mask_cls, dim=-1)[..., :-1]
- mask_pred = mask_pred.sigmoid()
- semseg = torch.einsum("qc,qhw->chw", mask_cls, mask_pred)
- return semseg
-
- def panoptic_inference(self, mask_cls, mask_pred):
- scores, labels = F.softmax(mask_cls, dim=-1).max(-1)
- mask_pred = mask_pred.sigmoid()
-
- keep = labels.ne(self.sem_seg_head.num_classes) & (scores > self.object_mask_threshold)
- cur_scores = scores[keep]
- cur_classes = labels[keep]
- cur_masks = mask_pred[keep]
- cur_mask_cls = mask_cls[keep]
- cur_mask_cls = cur_mask_cls[:, :-1]
-
- cur_prob_masks = cur_scores.view(-1, 1, 1) * cur_masks
-
- h, w = cur_masks.shape[-2:]
- panoptic_seg = torch.zeros((h, w), dtype=torch.int32, device=cur_masks.device)
- segments_info = []
-
- current_segment_id = 0
-
- if cur_masks.shape[0] == 0:
- # We didn't detect any mask :(
- return panoptic_seg, segments_info
- else:
- # take argmax
- cur_mask_ids = cur_prob_masks.argmax(0)
- stuff_memory_list = {}
- for k in range(cur_classes.shape[0]):
- pred_class = cur_classes[k].item()
- isthing = pred_class in self.metadata.thing_dataset_id_to_contiguous_id.values()
- mask_area = (cur_mask_ids == k).sum().item()
- original_area = (cur_masks[k] >= 0.5).sum().item()
- mask = (cur_mask_ids == k) & (cur_masks[k] >= 0.5)
-
- if mask_area > 0 and original_area > 0 and mask.sum().item() > 0:
- if mask_area / original_area < self.overlap_threshold:
- continue
-
- # merge stuff regions
- if not isthing:
- if int(pred_class) in stuff_memory_list.keys():
- panoptic_seg[mask] = stuff_memory_list[int(pred_class)]
- continue
- else:
- stuff_memory_list[int(pred_class)] = current_segment_id + 1
-
- current_segment_id += 1
- panoptic_seg[mask] = current_segment_id
-
- segments_info.append(
- {
- "id": current_segment_id,
- "isthing": bool(isthing),
- "category_id": int(pred_class),
- }
- )
-
- return panoptic_seg, segments_info
-
- def instance_inference(self, mask_cls, mask_pred, task_type):
- # mask_pred is already processed to have the same shape as original input
- image_size = mask_pred.shape[-2:]
-
- # [Q, K]
- scores = F.softmax(mask_cls, dim=-1)[:, :-1]
- labels = torch.arange(self.sem_seg_head.num_classes, device=self.device).unsqueeze(0).repeat(self.num_queries, 1).flatten(0, 1)
-
- # scores_per_image, topk_indices = scores.flatten(0, 1).topk(self.num_queries, sorted=False)
- scores_per_image, topk_indices = scores.flatten(0, 1).topk(self.test_topk_per_image, sorted=False)
- labels_per_image = labels[topk_indices]
-
- topk_indices = topk_indices // self.sem_seg_head.num_classes
- # mask_pred = mask_pred.unsqueeze(1).repeat(1, self.sem_seg_head.num_classes, 1).flatten(0, 1)
- mask_pred = mask_pred[topk_indices]
-
- # Only consider scores with confidence over [self.object_mask_threshold] for demo
- if self.is_demo:
- keep = scores_per_image > self.object_mask_threshold
- scores_per_image = scores_per_image[keep]
- labels_per_image = labels_per_image[keep]
- mask_pred = mask_pred[keep]
-
- # if this is panoptic segmentation, we only keep the "thing" classes
- if self.panoptic_on:
- keep = torch.zeros_like(scores_per_image).bool()
- for i, lab in enumerate(labels_per_image):
- keep[i] = lab in self.metadata.thing_dataset_id_to_contiguous_id.values()
-
- scores_per_image = scores_per_image[keep]
- labels_per_image = labels_per_image[keep]
- mask_pred = mask_pred[keep]
-
- if 'ade20k' in self.metadata.name and not self.is_demo and "instance" in task_type:
- for i in range(labels_per_image.shape[0]):
- labels_per_image[i] = self.thing_indices.index(labels_per_image[i].item())
-
- result = Instances(image_size)
- # mask (before sigmoid)
- result.pred_masks = (mask_pred > 0).float()
- if self.detection_on:
- # Uncomment the following to get boxes from masks (this is slow)
- result.pred_boxes = BitMasks(mask_pred > 0).get_bounding_boxes()
- else:
- result.pred_boxes = Boxes(torch.zeros(mask_pred.size(0), 4))
-
- # calculate average mask prob
- mask_scores_per_image = (mask_pred.sigmoid().flatten(1) * result.pred_masks.flatten(1)).sum(1) / (result.pred_masks.flatten(1).sum(1) + 1e-6)
- result.scores = scores_per_image * mask_scores_per_image
- result.pred_classes = labels_per_image
- return result
\ No newline at end of file
diff --git a/spaces/PVIT/pvit/Home.py b/spaces/PVIT/pvit/Home.py
deleted file mode 100644
index 212349d3feab42d296b1cc2583840ccb3b346b49..0000000000000000000000000000000000000000
--- a/spaces/PVIT/pvit/Home.py
+++ /dev/null
@@ -1,616 +0,0 @@
-import os
-import re
-import copy
-import json
-import yaml
-import random
-import streamlit as st
-from PIL import Image, ImageDraw
-import requests
-import base64
-from io import BytesIO
-import seaborn as sns
-import matplotlib.pyplot as plt
-import pandas as pd
-
-from collections import defaultdict
-import datetime
-import json
-import os
-import time
-
-import gradio as gr
-import requests
-
-import hashlib
-import time
-
-import streamlit as st
-import streamlit.components.v1 as components
-from streamlit_chat import message as st_message
-from streamlit_drawable_canvas import st_canvas
-
-st.set_page_config(page_title="Model Chat", page_icon="🌍", layout="wide", initial_sidebar_state="collapsed")
-
-col_img, col_chat = st.columns([1, 1])
-with col_chat:
- with st.container():
- input_area = st.container()
- chatbox = st.container()
-
-# ==================== Conversation =================== #
-import dataclasses
-from enum import auto, Enum
-from typing import List, Tuple
-
-
-class SeparatorStyle(Enum):
- """Different separator style."""
- SINGLE = auto()
- TWO = auto()
-
-import re
-# Hack for displaying Region in Chatbot
-def convert_region_tags(text):
- pattern = r'(.*?)<\/Region>'
- replaced_text = re.sub(pattern, lambda m: '<Region>' + m.group(1).replace('<', '<').replace('>', '>') + '</Region>', text)
- return replaced_text
-
-@dataclasses.dataclass
-class Conversation:
- """A class that keeps all conversation history."""
- system: str
- roles: List[str]
- messages: List[List[str]]
- offset: int
- sep_style: SeparatorStyle = SeparatorStyle.SINGLE
- sep: str = "###"
- sep2: str = None
- version: str = "Unknown"
-
- skip_next: bool = False
-
- def get_prompt(self):
- if self.sep_style == SeparatorStyle.SINGLE:
- ret = self.system + self.sep
- for role, message in self.messages:
- if message:
- if type(message) is tuple:
- message, _, _ = message
- ret += role + ": " + message + self.sep
- else:
- ret += role + ":"
- return ret
- elif self.sep_style == SeparatorStyle.TWO:
- seps = [self.sep, self.sep2]
- ret = self.system + seps[0]
- for i, (role, message) in enumerate(self.messages):
- if message:
- if type(message) is tuple:
- message, _, _ = message
- ret += role + ": " + message + seps[i % 2]
- else:
- ret += role + ":"
- return ret
- else:
- raise ValueError(f"Invalid style: {self.sep_style}")
-
- def append_message(self, role, message):
- self.messages.append([role, message])
-
- def get_images(self, return_pil=False):
- images = []
- for i, (role, msg) in enumerate(self.messages[self.offset:]):
- if i % 2 == 0:
- if type(msg) is tuple:
- import base64
- from io import BytesIO
- from PIL import Image
- msg, image, image_process_mode = msg
- if image_process_mode == "Pad":
- def expand2square(pil_img, background_color=(122, 116, 104)):
- width, height = pil_img.size
- if width == height:
- return pil_img
- elif width > height:
- result = Image.new(pil_img.mode, (width, width), background_color)
- result.paste(pil_img, (0, (width - height) // 2))
- return result
- else:
- result = Image.new(pil_img.mode, (height, height), background_color)
- result.paste(pil_img, ((height - width) // 2, 0))
- return result
- image = expand2square(image)
- elif image_process_mode == "Crop":
- pass
- elif image_process_mode == "Resize":
- image = image.resize((224, 224))
- else:
- raise ValueError(f"Invalid image_process_mode: {image_process_mode}")
- max_hw, min_hw = max(image.size), min(image.size)
- aspect_ratio = max_hw / min_hw
- max_len, min_len = 800, 400
- shortest_edge = int(min(max_len / aspect_ratio, min_len, min_hw))
- longest_edge = int(shortest_edge * aspect_ratio)
- W, H = image.size
- if H > W:
- H, W = longest_edge, shortest_edge
- else:
- H, W = shortest_edge, longest_edge
- image = image.resize((W, H))
- if return_pil:
- images.append(image)
- else:
- buffered = BytesIO()
- image.save(buffered, format="JPEG")
- img_b64_str = base64.b64encode(buffered.getvalue()).decode()
- images.append(img_b64_str)
- return images
-
- def to_gradio_chatbot(self):
- ret = []
- for i, (role, msg) in enumerate(self.messages[self.offset:]):
- if i % 2 == 0:
- if type(msg) is tuple:
- import base64
- from io import BytesIO
- msg, image, image_process_mode = msg
- msg = convert_region_tags(msg)
- max_hw, min_hw = max(image.size), min(image.size)
- aspect_ratio = max_hw / min_hw
- max_len, min_len = 800, 400
- shortest_edge = int(min(max_len / aspect_ratio, min_len, min_hw))
- longest_edge = int(shortest_edge * aspect_ratio)
- W, H = image.size
- if H > W:
- H, W = longest_edge, shortest_edge
- else:
- H, W = shortest_edge, longest_edge
- image = image.resize((W, H))
- # image = image.resize((224, 224))
- buffered = BytesIO()
- image.save(buffered, format="JPEG")
- img_b64_str = base64.b64encode(buffered.getvalue()).decode()
- img_str = f'
'
- msg = msg.replace('', img_str)
- else:
- msg = convert_region_tags(msg)
- ret.append([msg, None])
- else:
- if isinstance(msg, str):
- msg = convert_region_tags(msg)
- ret[-1][-1] = msg
- return ret
-
- def copy(self):
- return Conversation(
- system=self.system,
- roles=self.roles,
- messages=[[x, y] for x, y in self.messages],
- offset=self.offset,
- sep_style=self.sep_style,
- sep=self.sep,
- sep2=self.sep2)
-
- def dict(self):
- if len(self.get_images()) > 0:
- return {
- "system": self.system,
- "roles": self.roles,
- "messages": [[x, y[0] if type(y) is tuple else y] for x, y in self.messages],
- "offset": self.offset,
- "sep": self.sep,
- "sep2": self.sep2,
- }
- return {
- "system": self.system,
- "roles": self.roles,
- "messages": self.messages,
- "offset": self.offset,
- "sep": self.sep,
- "sep2": self.sep2,
- }
-
-conv_vicuna_v1_1 = Conversation(
- system="A chat between a curious user and an artificial intelligence assistant. "
- "The assistant gives helpful, detailed, and polite answers to the user's questions.",
- roles=("USER", "ASSISTANT"),
- version="v1",
- messages=(),
- offset=0,
- sep_style=SeparatorStyle.TWO,
- sep=" ",
- sep2=" ",
-)
-
-default_conversation = conv_vicuna_v1_1
-
-# ==================== Chat =================== #
-
-
-def convert_bbox_to_region(bbox_xywh, image_width, image_height):
- bbox_x, bbox_y, bbox_w, bbox_h = bbox_xywh
- x1 = bbox_x
- y1 = bbox_y
- x2 = bbox_x + bbox_w
- y2 = bbox_y + bbox_h
-
- x1_normalized = x1 / image_width
- y1_normalized = y1 / image_height
- x2_normalized = x2 / image_width
- y2_normalized = y2 / image_height
-
- x1_norm = int(x1_normalized * 1000)
- y1_norm = int(y1_normalized * 1000)
- x2_norm = int(x2_normalized * 1000)
- y2_norm = int(y2_normalized * 1000)
-
- region_format = "\n'), is_user=(role==conv.roles[0]))
-
- # # show message
- # with chatbox:
- # st_message(message, is_user=True)
- if 'messages' not in st.session_state:
- st.session_state['messages'] = []
- if len(st.session_state['messages']) == 0:
- if '' not in message:
- message = '\n' + message
- st.session_state['messages'].append([conv.roles[0], message])
- conv.messages = copy.deepcopy(st.session_state['messages'])
- # conv.append_message(conv.roles[0], message)
- conv.append_message(conv.roles[1], None)
- prompt = conv.get_prompt()
-
- if 'canvas_result' in st.session_state:
- objects = st.session_state['canvas_result'].get('objects', [])
- for i, obj in enumerate(objects):
- prompt = prompt.replace(f'[REGION-{i}]', obj['bbox_label'])
-
- headers = {"User-Agent": "LLaVA Client"}
- pload = {
- "prompt": prompt,
- "images": [st.session_state['image']],
- "max_new_tokens": max_new_tokens,
- "temperature": temperature,
- "stop": conv.sep2,
- }
- print(prompt)
- response = requests.post(st.session_state['model_addr'] + "/worker_generate_stream", headers=headers,
- json=pload, stream=True)
- result = ""
- for chunk in response.iter_lines(chunk_size=8192, decode_unicode=False, delimiter=b"\0"):
- if chunk:
- data_t = json.loads(chunk.decode("utf-8"))
- output = data_t["text"].split(conv.roles[1]+':')[-1]
- result = output
-
- # # show response
- # with chatbox:
- # st_message(result)
- st.session_state['messages'].append([conv.roles[1], result])
-
-
-# Customize Streamlit UI using CSS # background-color: #eb5424;
-st.markdown("""
-
-""", unsafe_allow_html=True)
-
-# ==================== Draw Bounding Boxes =================== #
-
-COLORS = sns.color_palette("tab10", n_colors=10).as_hex()
-random.Random(32).shuffle(COLORS)
-
-def update_annotation_states(canvas_result, ratio, img_size):
- for obj in canvas_result['objects']:
- top = obj["top"] * ratio
- left = obj["left"] * ratio
- width = obj["width"] * ratio
- height = obj["height"] * ratio
- obj['bbox_label'] = convert_bbox_to_region([left, top, width, height], img_size[0], img_size[1])
- st.session_state['canvas_result'] = canvas_result
- st.session_state['label_color'] = COLORS[len(st.session_state['canvas_result']['objects'])+1]
-
-def init_canvas():
- if 'canvas_result' not in st.session_state:
- st.session_state['canvas_result'] = None
- if 'label_color' not in st.session_state:
- st.session_state['label_color'] = COLORS[0]
-
-def input_message(msg):
- st.session_state['input_message'] = msg
-
-
-def get_objects():
- canvas_result = st.session_state.get('canvas_result', {})
- if canvas_result is not None:
- objects = canvas_result.get('objects', [])
- else:
- objects = []
- return objects
-
-def format_object_str(input_str):
- if 'canvas_result' in st.session_state:
- objects = st.session_state['canvas_result'].get('objects', [])
- for i, obj in enumerate(objects):
- input_str = input_str.replace(f'[REGION-{i}]', obj['bbox_label'])
- return input_str
-
-# select model
-model_list = get_model_list()
-with col_img:
- model_name = st.selectbox(
- 'Choose a model to chat with',
- model_list
- )
-change_model(model_name)
-
-css = ''
-# upload image
-with col_img:
- image = st.file_uploader("Chat with Image", type=["png", "jpg", "jpeg"], on_change=clear_messages)
- img_fn = image.name if image is not None else None
-if image:
- init_chat(encode_img(image))
- init_canvas()
-
- img = Image.open(image).convert('RGB')
-
- width = 700
- height = round(width * img.size[1] * 1.0 / img.size[0])
- ratio = img.size[0] / width
-
- with st.sidebar:
- max_new_tokens = st.number_input('max_new_tokens', min_value=1, max_value=1024, value=128)
- temperature = st.number_input('temperature', min_value=0.0, max_value=1.0, value=0.0)
- drawing_mode = st.selectbox(
- "Drawing tool:", ("rect", "point", "line", "circle"),
- )
- drawing_mode = "transform" if st.checkbox("Move ROIs", False) else drawing_mode
- stroke_width = st.slider("Stroke width: ", 1, 25, 3)
- # bg_color = st.color_picker("Background color: ", "#eee", key="bg_color")
-
- # save_file = st.text_input("Save File", value="saved.jsonl")
- # save_button = st.button(label='Save')
-
- # if save_button:
- # if img_fn is None:
- # st.warning("Please upload an image first!")
- # else:
- # conversations_to_save = [{'from': role, 'value': format_object_str(conv)} for (role, conv) in st.session_state['messages']]
- # model_name = st.session_state['model_name']
- # save_dict = {
- # 'image': img_fn,
- # 'conversations': conversations_to_save,
- # 'info': {
- # 'model_name': model_name
- # }
- # }
-
- # save_image_path = os.path.join(chat_config['save_path'], 'images')
- # os.makedirs(save_image_path, exist_ok=True)
-
- # img.save(os.path.join(save_image_path, img_fn))
-
- # chat_save_path = os.path.join(chat_config['save_path'], save_file)
- # with open(chat_save_path, 'a+') as fout:
- # fout.write(json.dumps(save_dict) + '\n')
-
- # st.success('Save successfully!')
-
- with col_img:
- canvas_result = st_canvas(
- fill_color=st.session_state['label_color'] + "77", # Fixed fill color with some opacity
- stroke_width=stroke_width,
- stroke_color=st.session_state['label_color'] + "77",
- background_color="#eee",
- background_image=Image.open(image) if image else None,
- update_streamlit=True,
- width=width,
- height=height,
- drawing_mode=drawing_mode,
- point_display_radius=3 if drawing_mode == 'point' else 0,
- key="canvas"
- )
-
- if canvas_result.json_data is not None:
- update_annotation_states(canvas_result.json_data, ratio, img.size)
-
- if st.session_state.get('submit_btn', False):
- send_one_message(st.session_state['input_message'], max_new_tokens=max_new_tokens, temperature=temperature)
- st.session_state['input_message'] = ""
-
- with input_area:
- col3, col4, col5 = st.columns([5, 1, 1])
-
- with col3:
- message = st.text_input('User', key="input_message")
-
- with col4:
- submit_btn = st.button(label='submit', key='submit_btn')
-
- components.html(
- """
-
- """,
- height=0,
- width=0,
- )
-
- with col5:
- clear_btn = st.button(label='clear', on_click=clear_messages)
-
-
- objects = get_objects()
-
- if len(objects):
- bbox_cols = st.columns([1 for _ in range(len(objects))])
-
- def on_bbox_button_click(str):
- def f():
- st.session_state['input_message'] += str
- return f
-
- for i, (obj, bbox_col) in enumerate(zip(objects, bbox_cols)):
- with bbox_col:
- st.button(label=f'Region-{i}', on_click=on_bbox_button_click(f'[REGION-{i}]'))
- # css += f"#root > div:nth-child(1) > div.withScreencast > div > div > div > section.main.css-uf99v8.e1g8pov65 > div.block-container.css-z5fcl4.e1g8pov64 > div:nth-child(1) > div > div.css-ocqkz7.esravye3 > div:nth-child(2) > div:nth-child(1) > div > div:nth-child(1) > div > div:nth-child(1) > div > div:nth-child(2) > div:nth-child({i+1}) > div:nth-child(1) > div > div > div > button {{background-color:{obj['stroke'][:7]}; bottom: 0px}} \n" + '\n'
- css += f"#root > div:nth-child(1) > div.withScreencast > div > div > div > section.main.css-uf99v8.ea3mdgi5 > div.block-container.css-awvpbp.ea3mdgi4 > div:nth-child(1) > div > div.css-ocqkz7.e1f1d6gn3 > div:nth-child(2) > div:nth-child(1) > div > div:nth-child(1) > div > div:nth-child(1) > div > div:nth-child(3) > div:nth-child({i+1}) > div:nth-child(1) > div > div > div > button {{background-color:{obj['stroke'][:7]}; bottom: 0px}} \n" + '\n'
- # css += f"#root > div:nth-child(1) > div.withScreencast > div > div > div > section.main.css-uf99v8.ea3mdgi5 > div.block-container.css-awvpbp.ea3mdgi4 > div:nth-child(1) > div > div.css-ocqkz7.e1f1d6gn3 > div:nth-child(2) > div:nth-child(1) > div > div:nth-child(1) > div > div:nth-child(1) > div > div:nth-child(2) > div:nth-child({i+1}) > div:nth-child(1) > div > div > div > button {{background-color:{obj['stroke'][:7]}; bottom: 0px}} \n" + '\n'
-
- for i, (role, msg) in enumerate(st.session_state['messages']):
- with chatbox:
- st_message(msg.lstrip('\n'), is_user=(role==default_conversation.roles[0]), key=f'{i}-{msg}')
-
-st.markdown("", unsafe_allow_html=True)
-
-st.markdown(
-"""
---------------------
-### User Manual
-
-- **Step 1.** Upload an image here
-""")
-
-st.image("figures/upload_image.png")
-
-st.markdown(
-"""
-- **Step 2.** (Optional) You can draw bounding boxes on the image. Each box you draw creates a corresponding button of the same color.
-""")
-
-st.image("figures/bbox.png", width=512)
-
-st.markdown(
-"""
-- **Step 3.** Ask questions. Insert region tokens in the question by clicking on the `Region-i` button. For example:
-
-> What color is the dog in [REGION-0]?
-
-> What is the relationship between the dog in [REGION-0] and the dog in [REGION-1]?
-
-**Note**: This demo is in its experimental stage, and we are actively working on improvements.
-
-""")
\ No newline at end of file
diff --git a/spaces/PaddlePaddle/resnext101_32x16d_wsl/README.md b/spaces/PaddlePaddle/resnext101_32x16d_wsl/README.md
deleted file mode 100644
index b2d7f59e4797ad8ef5ff596d95fb0b3175dabfdc..0000000000000000000000000000000000000000
--- a/spaces/PaddlePaddle/resnext101_32x16d_wsl/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Resnext101_32x16d_wsl
-emoji: 😻
-colorFrom: yellow
-colorTo: yellow
-sdk: gradio
-sdk_version: 2.9.4
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference
diff --git a/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/guile/2.2/ccache/language/cps/self-references.go b/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/guile/2.2/ccache/language/cps/self-references.go
deleted file mode 100644
index 98bb1c1b69ef6b8e2527feacd43ecba1c5a28a02..0000000000000000000000000000000000000000
Binary files a/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/guile/2.2/ccache/language/cps/self-references.go and /dev/null differ
diff --git a/spaces/Pinwheel/GLIP-BLIP-Object-Detection-VQA/maskrcnn_benchmark/utils/amp.py b/spaces/Pinwheel/GLIP-BLIP-Object-Detection-VQA/maskrcnn_benchmark/utils/amp.py
deleted file mode 100644
index ed97eb5b413a7f8375c3faa2135b0e3f3add230a..0000000000000000000000000000000000000000
--- a/spaces/Pinwheel/GLIP-BLIP-Object-Detection-VQA/maskrcnn_benchmark/utils/amp.py
+++ /dev/null
@@ -1,14 +0,0 @@
-from contextlib import contextmanager
-
-@contextmanager
-def nullcontext(enter_result=None, **kwargs):
- yield enter_result
-
-try:
- from torch.cuda.amp import autocast, GradScaler, custom_fwd, custom_bwd
-except:
- print('[Warning] Library for automatic mixed precision is not found, AMP is disabled!!')
- GradScaler = nullcontext
- autocast = nullcontext
- custom_fwd = nullcontext
- custom_bwd = nullcontext
\ No newline at end of file
diff --git a/spaces/Prof-Reza/Audiocraft_Music-Audio_Generation/audiocraft/quantization/vq.py b/spaces/Prof-Reza/Audiocraft_Music-Audio_Generation/audiocraft/quantization/vq.py
deleted file mode 100644
index aa57bea59db95ddae35e0657f723ca3a29ee943b..0000000000000000000000000000000000000000
--- a/spaces/Prof-Reza/Audiocraft_Music-Audio_Generation/audiocraft/quantization/vq.py
+++ /dev/null
@@ -1,115 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-import math
-import typing as tp
-
-import torch
-
-from .base import BaseQuantizer, QuantizedResult
-from .core_vq import ResidualVectorQuantization
-
-
-class ResidualVectorQuantizer(BaseQuantizer):
- """Residual Vector Quantizer.
-
- Args:
- dimension (int): Dimension of the codebooks.
- n_q (int): Number of residual vector quantizers used.
- q_dropout (bool): Random quantizer drop out at train time.
- bins (int): Codebook size.
- decay (float): Decay for exponential moving average over the codebooks.
- kmeans_init (bool): Whether to use kmeans to initialize the codebooks.
- kmeans_iters (int): Number of iterations used for kmeans initialization.
- threshold_ema_dead_code (int): Threshold for dead code expiration. Replace any codes
- that have an exponential moving average cluster size less than the specified threshold with
- randomly selected vector from the current batch.
- orthogonal_reg_weight (float): Orthogonal regularization weights.
- orthogonal_reg_active_codes_only (bool): Apply orthogonal regularization only on active codes.
- orthogonal_reg_max_codes (optional int): Maximum number of codes to consider.
- for orthogonal regularization.
- """
- def __init__(
- self,
- dimension: int = 256,
- n_q: int = 8,
- q_dropout: bool = False,
- bins: int = 1024,
- decay: float = 0.99,
- kmeans_init: bool = True,
- kmeans_iters: int = 10,
- threshold_ema_dead_code: int = 2,
- orthogonal_reg_weight: float = 0.0,
- orthogonal_reg_active_codes_only: bool = False,
- orthogonal_reg_max_codes: tp.Optional[int] = None,
- ):
- super().__init__()
- self.max_n_q = n_q
- self.n_q = n_q
- self.q_dropout = q_dropout
- self.dimension = dimension
- self.bins = bins
- self.decay = decay
- self.kmeans_init = kmeans_init
- self.kmeans_iters = kmeans_iters
- self.threshold_ema_dead_code = threshold_ema_dead_code
- self.orthogonal_reg_weight = orthogonal_reg_weight
- self.orthogonal_reg_active_codes_only = orthogonal_reg_active_codes_only
- self.orthogonal_reg_max_codes = orthogonal_reg_max_codes
- self.vq = ResidualVectorQuantization(
- dim=self.dimension,
- codebook_size=self.bins,
- num_quantizers=self.n_q,
- decay=self.decay,
- kmeans_init=self.kmeans_init,
- kmeans_iters=self.kmeans_iters,
- threshold_ema_dead_code=self.threshold_ema_dead_code,
- orthogonal_reg_weight=self.orthogonal_reg_weight,
- orthogonal_reg_active_codes_only=self.orthogonal_reg_active_codes_only,
- orthogonal_reg_max_codes=self.orthogonal_reg_max_codes,
- channels_last=False
- )
-
- def forward(self, x: torch.Tensor, frame_rate: int):
- n_q = self.n_q
- if self.training and self.q_dropout:
- n_q = int(torch.randint(1, self.n_q + 1, (1,)).item())
- bw_per_q = math.log2(self.bins) * frame_rate / 1000
- quantized, codes, commit_loss = self.vq(x, n_q=n_q)
- codes = codes.transpose(0, 1)
- # codes is [B, K, T], with T frames, K nb of codebooks.
- bw = torch.tensor(n_q * bw_per_q).to(x)
- return QuantizedResult(quantized, codes, bw, penalty=torch.mean(commit_loss))
-
- def encode(self, x: torch.Tensor) -> torch.Tensor:
- """Encode a given input tensor with the specified frame rate at the given bandwidth.
- The RVQ encode method sets the appropriate number of quantizer to use
- and returns indices for each quantizer.
- """
- n_q = self.n_q
- codes = self.vq.encode(x, n_q=n_q)
- codes = codes.transpose(0, 1)
- # codes is [B, K, T], with T frames, K nb of codebooks.
- return codes
-
- def decode(self, codes: torch.Tensor) -> torch.Tensor:
- """Decode the given codes to the quantized representation."""
- # codes is [B, K, T], with T frames, K nb of codebooks, vq.decode expects [K, B, T].
- codes = codes.transpose(0, 1)
- quantized = self.vq.decode(codes)
- return quantized
-
- @property
- def total_codebooks(self):
- return self.max_n_q
-
- @property
- def num_codebooks(self):
- return self.n_q
-
- def set_num_codebooks(self, n: int):
- assert n > 0 and n <= self.max_n_q
- self.n_q = n
diff --git a/spaces/PunGrumpy/text-generation/README.md b/spaces/PunGrumpy/text-generation/README.md
deleted file mode 100644
index cf6a8c1091f47d56b7dda8f7bb088cef8b963459..0000000000000000000000000000000000000000
--- a/spaces/PunGrumpy/text-generation/README.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: Text Generation
-emoji: 🐨
-colorFrom: red
-colorTo: pink
-sdk: docker
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_internal/utils/inject_securetransport.py b/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_internal/utils/inject_securetransport.py
deleted file mode 100644
index 276aa79bb81356cdca73af0a5851b448707784a4..0000000000000000000000000000000000000000
--- a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_internal/utils/inject_securetransport.py
+++ /dev/null
@@ -1,35 +0,0 @@
-"""A helper module that injects SecureTransport, on import.
-
-The import should be done as early as possible, to ensure all requests and
-sessions (or whatever) are created after injecting SecureTransport.
-
-Note that we only do the injection on macOS, when the linked OpenSSL is too
-old to handle TLSv1.2.
-"""
-
-import sys
-
-
-def inject_securetransport() -> None:
- # Only relevant on macOS
- if sys.platform != "darwin":
- return
-
- try:
- import ssl
- except ImportError:
- return
-
- # Checks for OpenSSL 1.0.1
- if ssl.OPENSSL_VERSION_NUMBER >= 0x1000100F:
- return
-
- try:
- from pip._vendor.urllib3.contrib import securetransport
- except (ImportError, OSError):
- return
-
- securetransport.inject_into_urllib3()
-
-
-inject_securetransport()
diff --git a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/chardet/utf8prober.py b/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/chardet/utf8prober.py
deleted file mode 100644
index 3aae09e863036b6185cf115047e441b15ea8c5e8..0000000000000000000000000000000000000000
--- a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/chardet/utf8prober.py
+++ /dev/null
@@ -1,80 +0,0 @@
-######################## BEGIN LICENSE BLOCK ########################
-# The Original Code is mozilla.org code.
-#
-# The Initial Developer of the Original Code is
-# Netscape Communications Corporation.
-# Portions created by the Initial Developer are Copyright (C) 1998
-# the Initial Developer. All Rights Reserved.
-#
-# Contributor(s):
-# Mark Pilgrim - port to Python
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
-# 02110-1301 USA
-######################### END LICENSE BLOCK #########################
-
-from .charsetprober import CharSetProber
-from .codingstatemachine import CodingStateMachine
-from .enums import MachineState, ProbingState
-from .mbcssm import UTF8_SM_MODEL
-
-
-class UTF8Prober(CharSetProber):
- ONE_CHAR_PROB = 0.5
-
- def __init__(self):
- super().__init__()
- self.coding_sm = CodingStateMachine(UTF8_SM_MODEL)
- self._num_mb_chars = None
- self.reset()
-
- def reset(self):
- super().reset()
- self.coding_sm.reset()
- self._num_mb_chars = 0
-
- @property
- def charset_name(self):
- return "utf-8"
-
- @property
- def language(self):
- return ""
-
- def feed(self, byte_str):
- for c in byte_str:
- coding_state = self.coding_sm.next_state(c)
- if coding_state == MachineState.ERROR:
- self._state = ProbingState.NOT_ME
- break
- if coding_state == MachineState.ITS_ME:
- self._state = ProbingState.FOUND_IT
- break
- if coding_state == MachineState.START:
- if self.coding_sm.get_current_charlen() >= 2:
- self._num_mb_chars += 1
-
- if self.state == ProbingState.DETECTING:
- if self.get_confidence() > self.SHORTCUT_THRESHOLD:
- self._state = ProbingState.FOUND_IT
-
- return self.state
-
- def get_confidence(self):
- unlike = 0.99
- if self._num_mb_chars < 6:
- unlike *= self.ONE_CHAR_PROB**self._num_mb_chars
- return 1.0 - unlike
- return unlike
diff --git a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmcv/runner/hooks/ema.py b/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmcv/runner/hooks/ema.py
deleted file mode 100644
index 15c7e68088f019802a59e7ae41cc1fe0c7f28f96..0000000000000000000000000000000000000000
--- a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmcv/runner/hooks/ema.py
+++ /dev/null
@@ -1,89 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from ...parallel import is_module_wrapper
-from ..hooks.hook import HOOKS, Hook
-
-
-@HOOKS.register_module()
-class EMAHook(Hook):
- r"""Exponential Moving Average Hook.
-
- Use Exponential Moving Average on all parameters of model in training
- process. All parameters have a ema backup, which update by the formula
- as below. EMAHook takes priority over EvalHook and CheckpointSaverHook.
-
- .. math::
-
- \text{Xema\_{t+1}} = (1 - \text{momentum}) \times
- \text{Xema\_{t}} + \text{momentum} \times X_t
-
- Args:
- momentum (float): The momentum used for updating ema parameter.
- Defaults to 0.0002.
- interval (int): Update ema parameter every interval iteration.
- Defaults to 1.
- warm_up (int): During first warm_up steps, we may use smaller momentum
- to update ema parameters more slowly. Defaults to 100.
- resume_from (str): The checkpoint path. Defaults to None.
- """
-
- def __init__(self,
- momentum=0.0002,
- interval=1,
- warm_up=100,
- resume_from=None):
- assert isinstance(interval, int) and interval > 0
- self.warm_up = warm_up
- self.interval = interval
- assert momentum > 0 and momentum < 1
- self.momentum = momentum**interval
- self.checkpoint = resume_from
-
- def before_run(self, runner):
- """To resume model with it's ema parameters more friendly.
-
- Register ema parameter as ``named_buffer`` to model
- """
- model = runner.model
- if is_module_wrapper(model):
- model = model.module
- self.param_ema_buffer = {}
- self.model_parameters = dict(model.named_parameters(recurse=True))
- for name, value in self.model_parameters.items():
- # "." is not allowed in module's buffer name
- buffer_name = f"ema_{name.replace('.', '_')}"
- self.param_ema_buffer[name] = buffer_name
- model.register_buffer(buffer_name, value.data.clone())
- self.model_buffers = dict(model.named_buffers(recurse=True))
- if self.checkpoint is not None:
- runner.resume(self.checkpoint)
-
- def after_train_iter(self, runner):
- """Update ema parameter every self.interval iterations."""
- curr_step = runner.iter
- # We warm up the momentum considering the instability at beginning
- momentum = min(self.momentum,
- (1 + curr_step) / (self.warm_up + curr_step))
- if curr_step % self.interval != 0:
- return
- for name, parameter in self.model_parameters.items():
- buffer_name = self.param_ema_buffer[name]
- buffer_parameter = self.model_buffers[buffer_name]
- buffer_parameter.mul_(1 - momentum).add_(momentum, parameter.data)
-
- def after_train_epoch(self, runner):
- """We load parameter values from ema backup to model before the
- EvalHook."""
- self._swap_ema_parameters()
-
- def before_train_epoch(self, runner):
- """We recover model's parameter from ema backup after last epoch's
- EvalHook."""
- self._swap_ema_parameters()
-
- def _swap_ema_parameters(self):
- """Swap the parameter of model with parameter in ema_buffer."""
- for name, value in self.model_parameters.items():
- temp = value.data.clone()
- ema_buffer = self.model_buffers[self.param_ema_buffer[name]]
- value.data.copy_(ema_buffer.data)
- ema_buffer.data.copy_(temp)
diff --git a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmdet/models/dense_heads/__init__.py b/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmdet/models/dense_heads/__init__.py
deleted file mode 100644
index f004dd95d97df16167f932587b3ce73b05b04a37..0000000000000000000000000000000000000000
--- a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmdet/models/dense_heads/__init__.py
+++ /dev/null
@@ -1,41 +0,0 @@
-from .anchor_free_head import AnchorFreeHead
-from .anchor_head import AnchorHead
-from .atss_head import ATSSHead
-from .cascade_rpn_head import CascadeRPNHead, StageCascadeRPNHead
-from .centripetal_head import CentripetalHead
-from .corner_head import CornerHead
-from .embedding_rpn_head import EmbeddingRPNHead
-from .fcos_head import FCOSHead
-from .fovea_head import FoveaHead
-from .free_anchor_retina_head import FreeAnchorRetinaHead
-from .fsaf_head import FSAFHead
-from .ga_retina_head import GARetinaHead
-from .ga_rpn_head import GARPNHead
-from .gfl_head import GFLHead
-from .guided_anchor_head import FeatureAdaption, GuidedAnchorHead
-from .ld_head import LDHead
-from .nasfcos_head import NASFCOSHead
-from .paa_head import PAAHead
-from .pisa_retinanet_head import PISARetinaHead
-from .pisa_ssd_head import PISASSDHead
-from .reppoints_head import RepPointsHead
-from .retina_head import RetinaHead
-from .retina_sepbn_head import RetinaSepBNHead
-from .rpn_head import RPNHead
-from .sabl_retina_head import SABLRetinaHead
-from .ssd_head import SSDHead
-from .transformer_head import TransformerHead
-from .vfnet_head import VFNetHead
-from .yolact_head import YOLACTHead, YOLACTProtonet, YOLACTSegmHead
-from .yolo_head import YOLOV3Head
-
-__all__ = [
- 'AnchorFreeHead', 'AnchorHead', 'GuidedAnchorHead', 'FeatureAdaption',
- 'RPNHead', 'GARPNHead', 'RetinaHead', 'RetinaSepBNHead', 'GARetinaHead',
- 'SSDHead', 'FCOSHead', 'RepPointsHead', 'FoveaHead',
- 'FreeAnchorRetinaHead', 'ATSSHead', 'FSAFHead', 'NASFCOSHead',
- 'PISARetinaHead', 'PISASSDHead', 'GFLHead', 'CornerHead', 'YOLACTHead',
- 'YOLACTSegmHead', 'YOLACTProtonet', 'YOLOV3Head', 'PAAHead',
- 'SABLRetinaHead', 'CentripetalHead', 'VFNetHead', 'TransformerHead',
- 'StageCascadeRPNHead', 'CascadeRPNHead', 'EmbeddingRPNHead', 'LDHead'
-]
diff --git a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmdet_null/models/necks/pafpn.py b/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmdet_null/models/necks/pafpn.py
deleted file mode 100644
index d7c0b50f29e882aacb5158b33ead3d4566d0ce0b..0000000000000000000000000000000000000000
--- a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmdet_null/models/necks/pafpn.py
+++ /dev/null
@@ -1,142 +0,0 @@
-import torch.nn as nn
-import torch.nn.functional as F
-from mmcv.cnn import ConvModule
-from mmcv.runner import auto_fp16
-
-from ..builder import NECKS
-from .fpn import FPN
-
-
-@NECKS.register_module()
-class PAFPN(FPN):
- """Path Aggregation Network for Instance Segmentation.
-
- This is an implementation of the `PAFPN in Path Aggregation Network
- `_.
-
- Args:
- in_channels (List[int]): Number of input channels per scale.
- out_channels (int): Number of output channels (used at each scale)
- num_outs (int): Number of output scales.
- start_level (int): Index of the start input backbone level used to
- build the feature pyramid. Default: 0.
- end_level (int): Index of the end input backbone level (exclusive) to
- build the feature pyramid. Default: -1, which means the last level.
- add_extra_convs (bool): Whether to add conv layers on top of the
- original feature maps. Default: False.
- extra_convs_on_inputs (bool): Whether to apply extra conv on
- the original feature from the backbone. Default: False.
- relu_before_extra_convs (bool): Whether to apply relu before the extra
- conv. Default: False.
- no_norm_on_lateral (bool): Whether to apply norm on lateral.
- Default: False.
- conv_cfg (dict): Config dict for convolution layer. Default: None.
- norm_cfg (dict): Config dict for normalization layer. Default: None.
- act_cfg (str): Config dict for activation layer in ConvModule.
- Default: None.
- """
-
- def __init__(self,
- in_channels,
- out_channels,
- num_outs,
- start_level=0,
- end_level=-1,
- add_extra_convs=False,
- extra_convs_on_inputs=True,
- relu_before_extra_convs=False,
- no_norm_on_lateral=False,
- conv_cfg=None,
- norm_cfg=None,
- act_cfg=None):
- super(PAFPN,
- self).__init__(in_channels, out_channels, num_outs, start_level,
- end_level, add_extra_convs, extra_convs_on_inputs,
- relu_before_extra_convs, no_norm_on_lateral,
- conv_cfg, norm_cfg, act_cfg)
- # add extra bottom up pathway
- self.downsample_convs = nn.ModuleList()
- self.pafpn_convs = nn.ModuleList()
- for i in range(self.start_level + 1, self.backbone_end_level):
- d_conv = ConvModule(
- out_channels,
- out_channels,
- 3,
- stride=2,
- padding=1,
- conv_cfg=conv_cfg,
- norm_cfg=norm_cfg,
- act_cfg=act_cfg,
- inplace=False)
- pafpn_conv = ConvModule(
- out_channels,
- out_channels,
- 3,
- padding=1,
- conv_cfg=conv_cfg,
- norm_cfg=norm_cfg,
- act_cfg=act_cfg,
- inplace=False)
- self.downsample_convs.append(d_conv)
- self.pafpn_convs.append(pafpn_conv)
-
- @auto_fp16()
- def forward(self, inputs):
- """Forward function."""
- assert len(inputs) == len(self.in_channels)
-
- # build laterals
- laterals = [
- lateral_conv(inputs[i + self.start_level])
- for i, lateral_conv in enumerate(self.lateral_convs)
- ]
-
- # build top-down path
- used_backbone_levels = len(laterals)
- for i in range(used_backbone_levels - 1, 0, -1):
- prev_shape = laterals[i - 1].shape[2:]
- laterals[i - 1] += F.interpolate(
- laterals[i], size=prev_shape, mode='nearest')
-
- # build outputs
- # part 1: from original levels
- inter_outs = [
- self.fpn_convs[i](laterals[i]) for i in range(used_backbone_levels)
- ]
-
- # part 2: add bottom-up path
- for i in range(0, used_backbone_levels - 1):
- inter_outs[i + 1] += self.downsample_convs[i](inter_outs[i])
-
- outs = []
- outs.append(inter_outs[0])
- outs.extend([
- self.pafpn_convs[i - 1](inter_outs[i])
- for i in range(1, used_backbone_levels)
- ])
-
- # part 3: add extra levels
- if self.num_outs > len(outs):
- # use max pool to get more levels on top of outputs
- # (e.g., Faster R-CNN, Mask R-CNN)
- if not self.add_extra_convs:
- for i in range(self.num_outs - used_backbone_levels):
- outs.append(F.max_pool2d(outs[-1], 1, stride=2))
- # add conv layers on top of original feature maps (RetinaNet)
- else:
- if self.add_extra_convs == 'on_input':
- orig = inputs[self.backbone_end_level - 1]
- outs.append(self.fpn_convs[used_backbone_levels](orig))
- elif self.add_extra_convs == 'on_lateral':
- outs.append(self.fpn_convs[used_backbone_levels](
- laterals[-1]))
- elif self.add_extra_convs == 'on_output':
- outs.append(self.fpn_convs[used_backbone_levels](outs[-1]))
- else:
- raise NotImplementedError
- for i in range(used_backbone_levels + 1, self.num_outs):
- if self.relu_before_extra_convs:
- outs.append(self.fpn_convs[i](F.relu(outs[-1])))
- else:
- outs.append(self.fpn_convs[i](outs[-1]))
- return tuple(outs)
diff --git a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmseg/models/backbones/uniformer.py b/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmseg/models/backbones/uniformer.py
deleted file mode 100644
index 0c4bb88e4c928540cca9ab609988b916520f5b7a..0000000000000000000000000000000000000000
--- a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmseg/models/backbones/uniformer.py
+++ /dev/null
@@ -1,422 +0,0 @@
-# --------------------------------------------------------
-# UniFormer
-# Copyright (c) 2022 SenseTime X-Lab
-# Licensed under The MIT License [see LICENSE for details]
-# Written by Kunchang Li
-# --------------------------------------------------------
-
-from collections import OrderedDict
-import math
-
-from functools import partial
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.utils.checkpoint as checkpoint
-import numpy as np
-from timm.models.layers import DropPath, to_2tuple, trunc_normal_
-
-from annotator.uniformer.mmcv_custom import load_checkpoint
-from annotator.uniformer.mmseg.utils import get_root_logger
-from ..builder import BACKBONES
-
-
-class Mlp(nn.Module):
- def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
- super().__init__()
- out_features = out_features or in_features
- hidden_features = hidden_features or in_features
- self.fc1 = nn.Linear(in_features, hidden_features)
- self.act = act_layer()
- self.fc2 = nn.Linear(hidden_features, out_features)
- self.drop = nn.Dropout(drop)
-
- def forward(self, x):
- x = self.fc1(x)
- x = self.act(x)
- x = self.drop(x)
- x = self.fc2(x)
- x = self.drop(x)
- return x
-
-
-class CMlp(nn.Module):
- def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
- super().__init__()
- out_features = out_features or in_features
- hidden_features = hidden_features or in_features
- self.fc1 = nn.Conv2d(in_features, hidden_features, 1)
- self.act = act_layer()
- self.fc2 = nn.Conv2d(hidden_features, out_features, 1)
- self.drop = nn.Dropout(drop)
-
- def forward(self, x):
- x = self.fc1(x)
- x = self.act(x)
- x = self.drop(x)
- x = self.fc2(x)
- x = self.drop(x)
- return x
-
-
-class CBlock(nn.Module):
- def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
- drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm):
- super().__init__()
- self.pos_embed = nn.Conv2d(dim, dim, 3, padding=1, groups=dim)
- self.norm1 = nn.BatchNorm2d(dim)
- self.conv1 = nn.Conv2d(dim, dim, 1)
- self.conv2 = nn.Conv2d(dim, dim, 1)
- self.attn = nn.Conv2d(dim, dim, 5, padding=2, groups=dim)
- # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here
- self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
- self.norm2 = nn.BatchNorm2d(dim)
- mlp_hidden_dim = int(dim * mlp_ratio)
- self.mlp = CMlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
-
- def forward(self, x):
- x = x + self.pos_embed(x)
- x = x + self.drop_path(self.conv2(self.attn(self.conv1(self.norm1(x)))))
- x = x + self.drop_path(self.mlp(self.norm2(x)))
- return x
-
-
-class Attention(nn.Module):
- def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., proj_drop=0.):
- super().__init__()
- self.num_heads = num_heads
- head_dim = dim // num_heads
- # NOTE scale factor was wrong in my original version, can set manually to be compat with prev weights
- self.scale = qk_scale or head_dim ** -0.5
-
- self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
- self.attn_drop = nn.Dropout(attn_drop)
- self.proj = nn.Linear(dim, dim)
- self.proj_drop = nn.Dropout(proj_drop)
-
- def forward(self, x):
- B, N, C = x.shape
- qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
- q, k, v = qkv[0], qkv[1], qkv[2] # make torchscript happy (cannot use tensor as tuple)
-
- attn = (q @ k.transpose(-2, -1)) * self.scale
- attn = attn.softmax(dim=-1)
- attn = self.attn_drop(attn)
-
- x = (attn @ v).transpose(1, 2).reshape(B, N, C)
- x = self.proj(x)
- x = self.proj_drop(x)
- return x
-
-
-class SABlock(nn.Module):
- def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
- drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm):
- super().__init__()
- self.pos_embed = nn.Conv2d(dim, dim, 3, padding=1, groups=dim)
- self.norm1 = norm_layer(dim)
- self.attn = Attention(
- dim,
- num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale,
- attn_drop=attn_drop, proj_drop=drop)
- # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here
- self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
- self.norm2 = norm_layer(dim)
- mlp_hidden_dim = int(dim * mlp_ratio)
- self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
-
- def forward(self, x):
- x = x + self.pos_embed(x)
- B, N, H, W = x.shape
- x = x.flatten(2).transpose(1, 2)
- x = x + self.drop_path(self.attn(self.norm1(x)))
- x = x + self.drop_path(self.mlp(self.norm2(x)))
- x = x.transpose(1, 2).reshape(B, N, H, W)
- return x
-
-
-def window_partition(x, window_size):
- """
- Args:
- x: (B, H, W, C)
- window_size (int): window size
- Returns:
- windows: (num_windows*B, window_size, window_size, C)
- """
- B, H, W, C = x.shape
- x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)
- windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)
- return windows
-
-
-def window_reverse(windows, window_size, H, W):
- """
- Args:
- windows: (num_windows*B, window_size, window_size, C)
- window_size (int): Window size
- H (int): Height of image
- W (int): Width of image
- Returns:
- x: (B, H, W, C)
- """
- B = int(windows.shape[0] / (H * W / window_size / window_size))
- x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)
- x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
- return x
-
-
-class SABlock_Windows(nn.Module):
- def __init__(self, dim, num_heads, window_size=14, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
- drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm):
- super().__init__()
- self.window_size=window_size
- self.pos_embed = nn.Conv2d(dim, dim, 3, padding=1, groups=dim)
- self.norm1 = norm_layer(dim)
- self.attn = Attention(
- dim,
- num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale,
- attn_drop=attn_drop, proj_drop=drop)
- # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here
- self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
- self.norm2 = norm_layer(dim)
- mlp_hidden_dim = int(dim * mlp_ratio)
- self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
-
- def forward(self, x):
- x = x + self.pos_embed(x)
- x = x.permute(0, 2, 3, 1)
- B, H, W, C = x.shape
- shortcut = x
- x = self.norm1(x)
-
- pad_l = pad_t = 0
- pad_r = (self.window_size - W % self.window_size) % self.window_size
- pad_b = (self.window_size - H % self.window_size) % self.window_size
- x = F.pad(x, (0, 0, pad_l, pad_r, pad_t, pad_b))
- _, Hp, Wp, _ = x.shape
-
- x_windows = window_partition(x, self.window_size) # nW*B, window_size, window_size, C
- x_windows = x_windows.view(-1, self.window_size * self.window_size, C) # nW*B, window_size*window_size, C
-
- # W-MSA/SW-MSA
- attn_windows = self.attn(x_windows) # nW*B, window_size*window_size, C
-
- # merge windows
- attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C)
- x = window_reverse(attn_windows, self.window_size, Hp, Wp) # B H' W' C
-
- # reverse cyclic shift
- if pad_r > 0 or pad_b > 0:
- x = x[:, :H, :W, :].contiguous()
-
- x = shortcut + self.drop_path(x)
- x = x + self.drop_path(self.mlp(self.norm2(x)))
- x = x.permute(0, 3, 1, 2).reshape(B, C, H, W)
- return x
-
-
-class PatchEmbed(nn.Module):
- """ Image to Patch Embedding
- """
- def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768):
- super().__init__()
- img_size = to_2tuple(img_size)
- patch_size = to_2tuple(patch_size)
- num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0])
- self.img_size = img_size
- self.patch_size = patch_size
- self.num_patches = num_patches
- self.norm = nn.LayerNorm(embed_dim)
- self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)
-
- def forward(self, x):
- B, _, H, W = x.shape
- x = self.proj(x)
- B, _, H, W = x.shape
- x = x.flatten(2).transpose(1, 2)
- x = self.norm(x)
- x = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous()
- return x
-
-
-@BACKBONES.register_module()
-class UniFormer(nn.Module):
- """ Vision Transformer
- A PyTorch impl of : `An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale` -
- https://arxiv.org/abs/2010.11929
- """
- def __init__(self, layers=[3, 4, 8, 3], img_size=224, in_chans=3, num_classes=80, embed_dim=[64, 128, 320, 512],
- head_dim=64, mlp_ratio=4., qkv_bias=True, qk_scale=None, representation_size=None,
- drop_rate=0., attn_drop_rate=0., drop_path_rate=0., norm_layer=partial(nn.LayerNorm, eps=1e-6),
- pretrained_path=None, use_checkpoint=False, checkpoint_num=[0, 0, 0, 0],
- windows=False, hybrid=False, window_size=14):
- """
- Args:
- layer (list): number of block in each layer
- img_size (int, tuple): input image size
- in_chans (int): number of input channels
- num_classes (int): number of classes for classification head
- embed_dim (int): embedding dimension
- head_dim (int): dimension of attention heads
- mlp_ratio (int): ratio of mlp hidden dim to embedding dim
- qkv_bias (bool): enable bias for qkv if True
- qk_scale (float): override default qk scale of head_dim ** -0.5 if set
- representation_size (Optional[int]): enable and set representation layer (pre-logits) to this value if set
- drop_rate (float): dropout rate
- attn_drop_rate (float): attention dropout rate
- drop_path_rate (float): stochastic depth rate
- norm_layer (nn.Module): normalization layer
- pretrained_path (str): path of pretrained model
- use_checkpoint (bool): whether use checkpoint
- checkpoint_num (list): index for using checkpoint in every stage
- windows (bool): whether use window MHRA
- hybrid (bool): whether use hybrid MHRA
- window_size (int): size of window (>14)
- """
- super().__init__()
- self.num_classes = num_classes
- self.use_checkpoint = use_checkpoint
- self.checkpoint_num = checkpoint_num
- self.windows = windows
- print(f'Use Checkpoint: {self.use_checkpoint}')
- print(f'Checkpoint Number: {self.checkpoint_num}')
- self.num_features = self.embed_dim = embed_dim # num_features for consistency with other models
- norm_layer = norm_layer or partial(nn.LayerNorm, eps=1e-6)
-
- self.patch_embed1 = PatchEmbed(
- img_size=img_size, patch_size=4, in_chans=in_chans, embed_dim=embed_dim[0])
- self.patch_embed2 = PatchEmbed(
- img_size=img_size // 4, patch_size=2, in_chans=embed_dim[0], embed_dim=embed_dim[1])
- self.patch_embed3 = PatchEmbed(
- img_size=img_size // 8, patch_size=2, in_chans=embed_dim[1], embed_dim=embed_dim[2])
- self.patch_embed4 = PatchEmbed(
- img_size=img_size // 16, patch_size=2, in_chans=embed_dim[2], embed_dim=embed_dim[3])
-
- self.pos_drop = nn.Dropout(p=drop_rate)
- dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(layers))] # stochastic depth decay rule
- num_heads = [dim // head_dim for dim in embed_dim]
- self.blocks1 = nn.ModuleList([
- CBlock(
- dim=embed_dim[0], num_heads=num_heads[0], mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
- drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i], norm_layer=norm_layer)
- for i in range(layers[0])])
- self.norm1=norm_layer(embed_dim[0])
- self.blocks2 = nn.ModuleList([
- CBlock(
- dim=embed_dim[1], num_heads=num_heads[1], mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
- drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i+layers[0]], norm_layer=norm_layer)
- for i in range(layers[1])])
- self.norm2 = norm_layer(embed_dim[1])
- if self.windows:
- print('Use local window for all blocks in stage3')
- self.blocks3 = nn.ModuleList([
- SABlock_Windows(
- dim=embed_dim[2], num_heads=num_heads[2], window_size=window_size, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
- drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i+layers[0]+layers[1]], norm_layer=norm_layer)
- for i in range(layers[2])])
- elif hybrid:
- print('Use hybrid window for blocks in stage3')
- block3 = []
- for i in range(layers[2]):
- if (i + 1) % 4 == 0:
- block3.append(SABlock(
- dim=embed_dim[2], num_heads=num_heads[2], mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
- drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i+layers[0]+layers[1]], norm_layer=norm_layer))
- else:
- block3.append(SABlock_Windows(
- dim=embed_dim[2], num_heads=num_heads[2], window_size=window_size, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
- drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i+layers[0]+layers[1]], norm_layer=norm_layer))
- self.blocks3 = nn.ModuleList(block3)
- else:
- print('Use global window for all blocks in stage3')
- self.blocks3 = nn.ModuleList([
- SABlock(
- dim=embed_dim[2], num_heads=num_heads[2], mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
- drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i+layers[0]+layers[1]], norm_layer=norm_layer)
- for i in range(layers[2])])
- self.norm3 = norm_layer(embed_dim[2])
- self.blocks4 = nn.ModuleList([
- SABlock(
- dim=embed_dim[3], num_heads=num_heads[3], mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
- drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i+layers[0]+layers[1]+layers[2]], norm_layer=norm_layer)
- for i in range(layers[3])])
- self.norm4 = norm_layer(embed_dim[3])
-
- # Representation layer
- if representation_size:
- self.num_features = representation_size
- self.pre_logits = nn.Sequential(OrderedDict([
- ('fc', nn.Linear(embed_dim, representation_size)),
- ('act', nn.Tanh())
- ]))
- else:
- self.pre_logits = nn.Identity()
-
- self.apply(self._init_weights)
- self.init_weights(pretrained=pretrained_path)
-
- def init_weights(self, pretrained):
- if isinstance(pretrained, str):
- logger = get_root_logger()
- load_checkpoint(self, pretrained, map_location='cpu', strict=False, logger=logger)
- print(f'Load pretrained model from {pretrained}')
- def _init_weights(self, m):
- if isinstance(m, nn.Linear):
- trunc_normal_(m.weight, std=.02)
- if isinstance(m, nn.Linear) and m.bias is not None:
- nn.init.constant_(m.bias, 0)
- elif isinstance(m, nn.LayerNorm):
- nn.init.constant_(m.bias, 0)
- nn.init.constant_(m.weight, 1.0)
-
- @torch.jit.ignore
- def no_weight_decay(self):
- return {'pos_embed', 'cls_token'}
-
- def get_classifier(self):
- return self.head
-
- def reset_classifier(self, num_classes, global_pool=''):
- self.num_classes = num_classes
- self.head = nn.Linear(self.embed_dim, num_classes) if num_classes > 0 else nn.Identity()
-
- def forward_features(self, x):
- out = []
- x = self.patch_embed1(x)
- x = self.pos_drop(x)
- for i, blk in enumerate(self.blocks1):
- if self.use_checkpoint and i < self.checkpoint_num[0]:
- x = checkpoint.checkpoint(blk, x)
- else:
- x = blk(x)
- x_out = self.norm1(x.permute(0, 2, 3, 1))
- out.append(x_out.permute(0, 3, 1, 2).contiguous())
- x = self.patch_embed2(x)
- for i, blk in enumerate(self.blocks2):
- if self.use_checkpoint and i < self.checkpoint_num[1]:
- x = checkpoint.checkpoint(blk, x)
- else:
- x = blk(x)
- x_out = self.norm2(x.permute(0, 2, 3, 1))
- out.append(x_out.permute(0, 3, 1, 2).contiguous())
- x = self.patch_embed3(x)
- for i, blk in enumerate(self.blocks3):
- if self.use_checkpoint and i < self.checkpoint_num[2]:
- x = checkpoint.checkpoint(blk, x)
- else:
- x = blk(x)
- x_out = self.norm3(x.permute(0, 2, 3, 1))
- out.append(x_out.permute(0, 3, 1, 2).contiguous())
- x = self.patch_embed4(x)
- for i, blk in enumerate(self.blocks4):
- if self.use_checkpoint and i < self.checkpoint_num[3]:
- x = checkpoint.checkpoint(blk, x)
- else:
- x = blk(x)
- x_out = self.norm4(x.permute(0, 2, 3, 1))
- out.append(x_out.permute(0, 3, 1, 2).contiguous())
- return tuple(out)
-
- def forward(self, x):
- x = self.forward_features(x)
- return x
diff --git a/spaces/Sa-m/Neural-Style-Transfer-Image-Stylization/README.md b/spaces/Sa-m/Neural-Style-Transfer-Image-Stylization/README.md
deleted file mode 100644
index e49db46d27d14c1512535a66844b7f44667fef13..0000000000000000000000000000000000000000
--- a/spaces/Sa-m/Neural-Style-Transfer-Image-Stylization/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Neural Style Transfer Image Stylization
-emoji: 🌍
-colorFrom: red
-colorTo: gray
-sdk: gradio
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference
diff --git a/spaces/Salesforce/EDICT/my_diffusers/commands/env.py b/spaces/Salesforce/EDICT/my_diffusers/commands/env.py
deleted file mode 100644
index 81a878bff6688d3c510b53c60ac9d0e51e4aebcc..0000000000000000000000000000000000000000
--- a/spaces/Salesforce/EDICT/my_diffusers/commands/env.py
+++ /dev/null
@@ -1,70 +0,0 @@
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import platform
-from argparse import ArgumentParser
-
-import huggingface_hub
-
-from .. import __version__ as version
-from ..utils import is_torch_available, is_transformers_available
-from . import BaseDiffusersCLICommand
-
-
-def info_command_factory(_):
- return EnvironmentCommand()
-
-
-class EnvironmentCommand(BaseDiffusersCLICommand):
- @staticmethod
- def register_subcommand(parser: ArgumentParser):
- download_parser = parser.add_parser("env")
- download_parser.set_defaults(func=info_command_factory)
-
- def run(self):
- hub_version = huggingface_hub.__version__
-
- pt_version = "not installed"
- pt_cuda_available = "NA"
- if is_torch_available():
- import torch
-
- pt_version = torch.__version__
- pt_cuda_available = torch.cuda.is_available()
-
- transformers_version = "not installed"
- if is_transformers_available:
- import transformers
-
- transformers_version = transformers.__version__
-
- info = {
- "`diffusers` version": version,
- "Platform": platform.platform(),
- "Python version": platform.python_version(),
- "PyTorch version (GPU?)": f"{pt_version} ({pt_cuda_available})",
- "Huggingface_hub version": hub_version,
- "Transformers version": transformers_version,
- "Using GPU in script?": "",
- "Using distributed or parallel set-up in script?": "",
- }
-
- print("\nCopy-and-paste the text below in your GitHub issue and FILL OUT the two last points.\n")
- print(self.format_dict(info))
-
- return info
-
- @staticmethod
- def format_dict(d):
- return "\n".join([f"- {prop}: {val}" for prop, val in d.items()]) + "\n"
diff --git a/spaces/Sandiago21/speech-to-speech-translation-german/app.py b/spaces/Sandiago21/speech-to-speech-translation-german/app.py
deleted file mode 100644
index e0c7bc8ac90450eeea216bb5a3333ffe10be347c..0000000000000000000000000000000000000000
--- a/spaces/Sandiago21/speech-to-speech-translation-german/app.py
+++ /dev/null
@@ -1,142 +0,0 @@
-import gradio as gr
-import numpy as np
-import torch
-from datasets import load_dataset
-from transformers import SpeechT5ForTextToSpeech, SpeechT5HifiGan, SpeechT5Processor, pipeline
-
-
-device = "cuda:0" if torch.cuda.is_available() else "cpu"
-
-# load speech translation checkpoint
-asr_pipe = pipeline("automatic-speech-recognition", model="openai/whisper-large-v2", device=device)
-
-# load text-to-speech checkpoint and speaker embeddings
-model_id = "Sandiago21/speecht5_finetuned_mozilla_foundation_common_voice_13_german" # update with your model id
-# pipe = pipeline("automatic-speech-recognition", model=model_id)
-model = SpeechT5ForTextToSpeech.from_pretrained(model_id)
-processor = SpeechT5Processor.from_pretrained(model_id)
-vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")
-embeddings_dataset = load_dataset("Matthijs/cmu-arctic-xvectors", split="validation")
-speaker_embeddings = torch.tensor(embeddings_dataset[7440]["xvector"]).unsqueeze(0)
-
-replacements = [
- ("Ä", "E"),
- ("Æ", "E"),
- ("Ç", "C"),
- ("É", "E"),
- ("Í", "I"),
- ("Ó", "O"),
- ("Ö", "E"),
- ("Ü", "Y"),
- ("ß", "S"),
- ("à", "a"),
- ("á", "a"),
- ("ã", "a"),
- ("ä", "e"),
- ("å", "a"),
- ("ë", "e"),
- ("í", "i"),
- ("ï", "i"),
- ("ð", "o"),
- ("ñ", "n"),
- ("ò", "o"),
- ("ó", "o"),
- ("ô", "o"),
- ("ö", "u"),
- ("ú", "u"),
- ("ü", "y"),
- ("ý", "y"),
- ("Ā", "A"),
- ("ā", "a"),
- ("ă", "a"),
- ("ą", "a"),
- ("ć", "c"),
- ("Č", "C"),
- ("č", "c"),
- ("ď", "d"),
- ("Đ", "D"),
- ("ę", "e"),
- ("ě", "e"),
- ("ğ", "g"),
- ("İ", "I"),
- ("О", "O"),
- ("Ł", "L"),
- ("ń", "n"),
- ("ň", "n"),
- ("Ō", "O"),
- ("ō", "o"),
- ("ő", "o"),
- ("ř", "r"),
- ("Ś", "S"),
- ("ś", "s"),
- ("Ş", "S"),
- ("ş", "s"),
- ("Š", "S"),
- ("š", "s"),
- ("ū", "u"),
- ("ź", "z"),
- ("Ż", "Z"),
- ("Ž", "Z"),
- ("ǐ", "i"),
- ("ǐ", "i"),
- ("ș", "s"),
- ("ț", "t"),
-]
-
-
-def cleanup_text(text):
- for src, dst in replacements:
- text = text.replace(src, dst)
- return text
-
-
-def transcribe_to_german(audio):
- outputs = asr_pipe(audio, max_new_tokens=256, generate_kwargs={"task": "transcribe", "language": "german"})
- return outputs["text"]
-
-
-def synthesise_from_german(text):
- text = cleanup_text(text)
- inputs = processor(text=text, return_tensors="pt")
- speech = model.generate_speech(inputs["input_ids"].to(device), speaker_embeddings.to(device), vocoder=vocoder)
- return speech.cpu()
-
-
-def speech_to_speech_translation(audio):
- translated_text = transcribe_to_german(audio)
- synthesised_speech = synthesise_from_german(translated_text)
- synthesised_speech = (synthesised_speech.numpy() * 32767).astype(np.int16)
- return ((16000, synthesised_speech), translated_text)
-
-
-title = "Cascaded STST"
-description = """
-Demo for cascaded speech-to-speech translation (STST), mapping from source speech in any language to target speech in German. Demo uses OpenAI's [Whisper Large v2](https://huggingface.co/openai/whisper-large-v2) model for speech translation, and [Sandiago21/speecht5_finetuned_mozilla_foundation_common_voice_13_german](https://huggingface.co/Sandiago21/speecht5_finetuned_mozilla_foundation_common_voice_13_german) checkpoint for text-to-speech, which is based on Microsoft's
-[SpeechT5 TTS](https://huggingface.co/microsoft/speecht5_tts) model for text-to-speech, fine-tuned in German Audio dataset:
-
-"""
-
-demo = gr.Blocks()
-
-mic_translate = gr.Interface(
- fn=speech_to_speech_translation,
- inputs=gr.Audio(source="microphone", type="filepath"),
- outputs=[gr.Audio(label="Generated Speech", type="numpy"), gr.outputs.Textbox()],
- title=title,
- description=description,
-)
-
-file_translate = gr.Interface(
- fn=speech_to_speech_translation,
- inputs=gr.Audio(source="upload", type="filepath"),
- outputs=[gr.Audio(label="Generated Speech", type="numpy"), gr.outputs.Textbox()],
- examples=[["./example.wav"]],
- title=title,
- description=description,
-)
-
-with demo:
- gr.TabbedInterface([mic_translate, file_translate], ["Microphone", "Audio File"])
-
-demo.launch()
-
diff --git a/spaces/Sapiensia/MakerDiffusion/README.md b/spaces/Sapiensia/MakerDiffusion/README.md
deleted file mode 100644
index 73a674b4248e0f183def5706750b386cbc39e86b..0000000000000000000000000000000000000000
--- a/spaces/Sapiensia/MakerDiffusion/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Basilisk-AI Maker Diffusion V-4.0
-emoji: 👁
-colorFrom: indigo
-colorTo: purple
-sdk: gradio
-sdk_version: 3.21.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/SarthakSidhant/Go-Cattle/diseases/mycotoxicosis.md b/spaces/SarthakSidhant/Go-Cattle/diseases/mycotoxicosis.md
deleted file mode 100644
index 72da57ca6e45604280b8adddcd265749b89d543e..0000000000000000000000000000000000000000
--- a/spaces/SarthakSidhant/Go-Cattle/diseases/mycotoxicosis.md
+++ /dev/null
@@ -1,36 +0,0 @@
-## Mycotoxicosis
-
-**Information:** Mycotoxicosis is a disease caused by the consumption of feed or forage contaminated with mycotoxins. Mycotoxins are poisonous substances produced by fungi, which can grow on a variety of crops, including corn, wheat, and hay.
-
-**Symptoms:**
-
-* The symptoms of mycotoxicosis can vary depending on the type of mycotoxin ingested, the amount ingested, and the animal's individual susceptibility. Some common symptoms include:
- * Loss of appetite
- * Weight loss
- * Diarrhea
- * Vomiting
- * Jaundice
- * Impaired reproduction
- * Death
-
-**Remedies:**
-
-* There is no specific treatment for mycotoxicosis. Treatment is usually supportive and may include:
- * Administering activated charcoal to absorb the mycotoxin
- * Providing fluids and electrolytes
- * Treating other underlying conditions
-
-**Causes:**
-
-* Mycotoxicosis is caused by the consumption of feed or forage contaminated with mycotoxins. Mycotoxins are produced by fungi, which can grow on a variety of crops, including corn, wheat, and hay.
-* Mycotoxins can be produced in the field, during storage, or during processing of feed and forage.
-* The risk of mycotoxicosis is increased in warm, humid conditions.
-
-**Prevention:**
-
-* The best way to prevent mycotoxicosis is to:
- * Feed cattle a balanced diet
- * Store feed and forage properly
- * Test feed and forage for mycotoxins
- * Use mycotoxin binders to reduce the absorption of mycotoxins
-
diff --git a/spaces/ServerX/PorcoDiaz/train/data_utils.py b/spaces/ServerX/PorcoDiaz/train/data_utils.py
deleted file mode 100644
index 71c0eff1815469a52399dc90a093a2f8a29223eb..0000000000000000000000000000000000000000
--- a/spaces/ServerX/PorcoDiaz/train/data_utils.py
+++ /dev/null
@@ -1,512 +0,0 @@
-import os, traceback
-import numpy as np
-import torch
-import torch.utils.data
-
-from mel_processing import spectrogram_torch
-from utils import load_wav_to_torch, load_filepaths_and_text
-
-
-class TextAudioLoaderMultiNSFsid(torch.utils.data.Dataset):
- """
- 1) loads audio, text pairs
- 2) normalizes text and converts them to sequences of integers
- 3) computes spectrograms from audio files.
- """
-
- def __init__(self, audiopaths_and_text, hparams):
- self.audiopaths_and_text = load_filepaths_and_text(audiopaths_and_text)
- self.max_wav_value = hparams.max_wav_value
- self.sampling_rate = hparams.sampling_rate
- self.filter_length = hparams.filter_length
- self.hop_length = hparams.hop_length
- self.win_length = hparams.win_length
- self.sampling_rate = hparams.sampling_rate
- self.min_text_len = getattr(hparams, "min_text_len", 1)
- self.max_text_len = getattr(hparams, "max_text_len", 5000)
- self._filter()
-
- def _filter(self):
- """
- Filter text & store spec lengths
- """
- # Store spectrogram lengths for Bucketing
- # wav_length ~= file_size / (wav_channels * Bytes per dim) = file_size / (1 * 2)
- # spec_length = wav_length // hop_length
- audiopaths_and_text_new = []
- lengths = []
- for audiopath, text, pitch, pitchf, dv in self.audiopaths_and_text:
- if self.min_text_len <= len(text) and len(text) <= self.max_text_len:
- audiopaths_and_text_new.append([audiopath, text, pitch, pitchf, dv])
- lengths.append(os.path.getsize(audiopath) // (3 * self.hop_length))
- self.audiopaths_and_text = audiopaths_and_text_new
- self.lengths = lengths
-
- def get_sid(self, sid):
- sid = torch.LongTensor([int(sid)])
- return sid
-
- def get_audio_text_pair(self, audiopath_and_text):
- # separate filename and text
- file = audiopath_and_text[0]
- phone = audiopath_and_text[1]
- pitch = audiopath_and_text[2]
- pitchf = audiopath_and_text[3]
- dv = audiopath_and_text[4]
-
- phone, pitch, pitchf = self.get_labels(phone, pitch, pitchf)
- spec, wav = self.get_audio(file)
- dv = self.get_sid(dv)
-
- len_phone = phone.size()[0]
- len_spec = spec.size()[-1]
- # print(123,phone.shape,pitch.shape,spec.shape)
- if len_phone != len_spec:
- len_min = min(len_phone, len_spec)
- # amor
- len_wav = len_min * self.hop_length
-
- spec = spec[:, :len_min]
- wav = wav[:, :len_wav]
-
- phone = phone[:len_min, :]
- pitch = pitch[:len_min]
- pitchf = pitchf[:len_min]
-
- return (spec, wav, phone, pitch, pitchf, dv)
-
- def get_labels(self, phone, pitch, pitchf):
- phone = np.load(phone)
- phone = np.repeat(phone, 2, axis=0)
- pitch = np.load(pitch)
- pitchf = np.load(pitchf)
- n_num = min(phone.shape[0], 900) # DistributedBucketSampler
- # print(234,phone.shape,pitch.shape)
- phone = phone[:n_num, :]
- pitch = pitch[:n_num]
- pitchf = pitchf[:n_num]
- phone = torch.FloatTensor(phone)
- pitch = torch.LongTensor(pitch)
- pitchf = torch.FloatTensor(pitchf)
- return phone, pitch, pitchf
-
- def get_audio(self, filename):
- audio, sampling_rate = load_wav_to_torch(filename)
- if sampling_rate != self.sampling_rate:
- raise ValueError(
- "{} SR doesn't match target {} SR".format(
- sampling_rate, self.sampling_rate
- )
- )
- audio_norm = audio
- # audio_norm = audio / self.max_wav_value
- # audio_norm = audio / np.abs(audio).max()
-
- audio_norm = audio_norm.unsqueeze(0)
- spec_filename = filename.replace(".wav", ".spec.pt")
- if os.path.exists(spec_filename):
- try:
- spec = torch.load(spec_filename)
- except:
- print(spec_filename, traceback.format_exc())
- spec = spectrogram_torch(
- audio_norm,
- self.filter_length,
- self.sampling_rate,
- self.hop_length,
- self.win_length,
- center=False,
- )
- spec = torch.squeeze(spec, 0)
- torch.save(spec, spec_filename, _use_new_zipfile_serialization=False)
- else:
- spec = spectrogram_torch(
- audio_norm,
- self.filter_length,
- self.sampling_rate,
- self.hop_length,
- self.win_length,
- center=False,
- )
- spec = torch.squeeze(spec, 0)
- torch.save(spec, spec_filename, _use_new_zipfile_serialization=False)
- return spec, audio_norm
-
- def __getitem__(self, index):
- return self.get_audio_text_pair(self.audiopaths_and_text[index])
-
- def __len__(self):
- return len(self.audiopaths_and_text)
-
-
-class TextAudioCollateMultiNSFsid:
- """Zero-pads model inputs and targets"""
-
- def __init__(self, return_ids=False):
- self.return_ids = return_ids
-
- def __call__(self, batch):
- """Collate's training batch from normalized text and aduio
- PARAMS
- ------
- batch: [text_normalized, spec_normalized, wav_normalized]
- """
- # Right zero-pad all one-hot text sequences to max input length
- _, ids_sorted_decreasing = torch.sort(
- torch.LongTensor([x[0].size(1) for x in batch]), dim=0, descending=True
- )
-
- max_spec_len = max([x[0].size(1) for x in batch])
- max_wave_len = max([x[1].size(1) for x in batch])
- spec_lengths = torch.LongTensor(len(batch))
- wave_lengths = torch.LongTensor(len(batch))
- spec_padded = torch.FloatTensor(len(batch), batch[0][0].size(0), max_spec_len)
- wave_padded = torch.FloatTensor(len(batch), 1, max_wave_len)
- spec_padded.zero_()
- wave_padded.zero_()
-
- max_phone_len = max([x[2].size(0) for x in batch])
- phone_lengths = torch.LongTensor(len(batch))
- phone_padded = torch.FloatTensor(
- len(batch), max_phone_len, batch[0][2].shape[1]
- ) # (spec, wav, phone, pitch)
- pitch_padded = torch.LongTensor(len(batch), max_phone_len)
- pitchf_padded = torch.FloatTensor(len(batch), max_phone_len)
- phone_padded.zero_()
- pitch_padded.zero_()
- pitchf_padded.zero_()
- # dv = torch.FloatTensor(len(batch), 256)#gin=256
- sid = torch.LongTensor(len(batch))
-
- for i in range(len(ids_sorted_decreasing)):
- row = batch[ids_sorted_decreasing[i]]
-
- spec = row[0]
- spec_padded[i, :, : spec.size(1)] = spec
- spec_lengths[i] = spec.size(1)
-
- wave = row[1]
- wave_padded[i, :, : wave.size(1)] = wave
- wave_lengths[i] = wave.size(1)
-
- phone = row[2]
- phone_padded[i, : phone.size(0), :] = phone
- phone_lengths[i] = phone.size(0)
-
- pitch = row[3]
- pitch_padded[i, : pitch.size(0)] = pitch
- pitchf = row[4]
- pitchf_padded[i, : pitchf.size(0)] = pitchf
-
- # dv[i] = row[5]
- sid[i] = row[5]
-
- return (
- phone_padded,
- phone_lengths,
- pitch_padded,
- pitchf_padded,
- spec_padded,
- spec_lengths,
- wave_padded,
- wave_lengths,
- # dv
- sid,
- )
-
-
-class TextAudioLoader(torch.utils.data.Dataset):
- """
- 1) loads audio, text pairs
- 2) normalizes text and converts them to sequences of integers
- 3) computes spectrograms from audio files.
- """
-
- def __init__(self, audiopaths_and_text, hparams):
- self.audiopaths_and_text = load_filepaths_and_text(audiopaths_and_text)
- self.max_wav_value = hparams.max_wav_value
- self.sampling_rate = hparams.sampling_rate
- self.filter_length = hparams.filter_length
- self.hop_length = hparams.hop_length
- self.win_length = hparams.win_length
- self.sampling_rate = hparams.sampling_rate
- self.min_text_len = getattr(hparams, "min_text_len", 1)
- self.max_text_len = getattr(hparams, "max_text_len", 5000)
- self._filter()
-
- def _filter(self):
- """
- Filter text & store spec lengths
- """
- # Store spectrogram lengths for Bucketing
- # wav_length ~= file_size / (wav_channels * Bytes per dim) = file_size / (1 * 2)
- # spec_length = wav_length // hop_length
- audiopaths_and_text_new = []
- lengths = []
- for audiopath, text, dv in self.audiopaths_and_text:
- if self.min_text_len <= len(text) and len(text) <= self.max_text_len:
- audiopaths_and_text_new.append([audiopath, text, dv])
- lengths.append(os.path.getsize(audiopath) // (3 * self.hop_length))
- self.audiopaths_and_text = audiopaths_and_text_new
- self.lengths = lengths
-
- def get_sid(self, sid):
- sid = torch.LongTensor([int(sid)])
- return sid
-
- def get_audio_text_pair(self, audiopath_and_text):
- # separate filename and text
- file = audiopath_and_text[0]
- phone = audiopath_and_text[1]
- dv = audiopath_and_text[2]
-
- phone = self.get_labels(phone)
- spec, wav = self.get_audio(file)
- dv = self.get_sid(dv)
-
- len_phone = phone.size()[0]
- len_spec = spec.size()[-1]
- if len_phone != len_spec:
- len_min = min(len_phone, len_spec)
- len_wav = len_min * self.hop_length
- spec = spec[:, :len_min]
- wav = wav[:, :len_wav]
- phone = phone[:len_min, :]
- return (spec, wav, phone, dv)
-
- def get_labels(self, phone):
- phone = np.load(phone)
- phone = np.repeat(phone, 2, axis=0)
- n_num = min(phone.shape[0], 900) # DistributedBucketSampler
- phone = phone[:n_num, :]
- phone = torch.FloatTensor(phone)
- return phone
-
- def get_audio(self, filename):
- audio, sampling_rate = load_wav_to_torch(filename)
- if sampling_rate != self.sampling_rate:
- raise ValueError(
- "{} SR doesn't match target {} SR".format(
- sampling_rate, self.sampling_rate
- )
- )
- audio_norm = audio
- # audio_norm = audio / self.max_wav_value
- # audio_norm = audio / np.abs(audio).max()
-
- audio_norm = audio_norm.unsqueeze(0)
- spec_filename = filename.replace(".wav", ".spec.pt")
- if os.path.exists(spec_filename):
- try:
- spec = torch.load(spec_filename)
- except:
- print(spec_filename, traceback.format_exc())
- spec = spectrogram_torch(
- audio_norm,
- self.filter_length,
- self.sampling_rate,
- self.hop_length,
- self.win_length,
- center=False,
- )
- spec = torch.squeeze(spec, 0)
- torch.save(spec, spec_filename, _use_new_zipfile_serialization=False)
- else:
- spec = spectrogram_torch(
- audio_norm,
- self.filter_length,
- self.sampling_rate,
- self.hop_length,
- self.win_length,
- center=False,
- )
- spec = torch.squeeze(spec, 0)
- torch.save(spec, spec_filename, _use_new_zipfile_serialization=False)
- return spec, audio_norm
-
- def __getitem__(self, index):
- return self.get_audio_text_pair(self.audiopaths_and_text[index])
-
- def __len__(self):
- return len(self.audiopaths_and_text)
-
-
-class TextAudioCollate:
- """Zero-pads model inputs and targets"""
-
- def __init__(self, return_ids=False):
- self.return_ids = return_ids
-
- def __call__(self, batch):
- """Collate's training batch from normalized text and aduio
- PARAMS
- ------
- batch: [text_normalized, spec_normalized, wav_normalized]
- """
- # Right zero-pad all one-hot text sequences to max input length
- _, ids_sorted_decreasing = torch.sort(
- torch.LongTensor([x[0].size(1) for x in batch]), dim=0, descending=True
- )
-
- max_spec_len = max([x[0].size(1) for x in batch])
- max_wave_len = max([x[1].size(1) for x in batch])
- spec_lengths = torch.LongTensor(len(batch))
- wave_lengths = torch.LongTensor(len(batch))
- spec_padded = torch.FloatTensor(len(batch), batch[0][0].size(0), max_spec_len)
- wave_padded = torch.FloatTensor(len(batch), 1, max_wave_len)
- spec_padded.zero_()
- wave_padded.zero_()
-
- max_phone_len = max([x[2].size(0) for x in batch])
- phone_lengths = torch.LongTensor(len(batch))
- phone_padded = torch.FloatTensor(
- len(batch), max_phone_len, batch[0][2].shape[1]
- )
- phone_padded.zero_()
- sid = torch.LongTensor(len(batch))
-
- for i in range(len(ids_sorted_decreasing)):
- row = batch[ids_sorted_decreasing[i]]
-
- spec = row[0]
- spec_padded[i, :, : spec.size(1)] = spec
- spec_lengths[i] = spec.size(1)
-
- wave = row[1]
- wave_padded[i, :, : wave.size(1)] = wave
- wave_lengths[i] = wave.size(1)
-
- phone = row[2]
- phone_padded[i, : phone.size(0), :] = phone
- phone_lengths[i] = phone.size(0)
-
- sid[i] = row[3]
-
- return (
- phone_padded,
- phone_lengths,
- spec_padded,
- spec_lengths,
- wave_padded,
- wave_lengths,
- sid,
- )
-
-
-class DistributedBucketSampler(torch.utils.data.distributed.DistributedSampler):
- """
- Maintain similar input lengths in a batch.
- Length groups are specified by boundaries.
- Ex) boundaries = [b1, b2, b3] -> any batch is included either {x | b1 < length(x) <=b2} or {x | b2 < length(x) <= b3}.
-
- It removes samples which are not included in the boundaries.
- Ex) boundaries = [b1, b2, b3] -> any x s.t. length(x) <= b1 or length(x) > b3 are discarded.
- """
-
- def __init__(
- self,
- dataset,
- batch_size,
- boundaries,
- num_replicas=None,
- rank=None,
- shuffle=True,
- ):
- super().__init__(dataset, num_replicas=num_replicas, rank=rank, shuffle=shuffle)
- self.lengths = dataset.lengths
- self.batch_size = batch_size
- self.boundaries = boundaries
-
- self.buckets, self.num_samples_per_bucket = self._create_buckets()
- self.total_size = sum(self.num_samples_per_bucket)
- self.num_samples = self.total_size // self.num_replicas
-
- def _create_buckets(self):
- buckets = [[] for _ in range(len(self.boundaries) - 1)]
- for i in range(len(self.lengths)):
- length = self.lengths[i]
- idx_bucket = self._bisect(length)
- if idx_bucket != -1:
- buckets[idx_bucket].append(i)
-
- for i in range(len(buckets) - 1, -1, -1): #
- if len(buckets[i]) == 0:
- buckets.pop(i)
- self.boundaries.pop(i + 1)
-
- num_samples_per_bucket = []
- for i in range(len(buckets)):
- len_bucket = len(buckets[i])
- total_batch_size = self.num_replicas * self.batch_size
- rem = (
- total_batch_size - (len_bucket % total_batch_size)
- ) % total_batch_size
- num_samples_per_bucket.append(len_bucket + rem)
- return buckets, num_samples_per_bucket
-
- def __iter__(self):
- # deterministically shuffle based on epoch
- g = torch.Generator()
- g.manual_seed(self.epoch)
-
- indices = []
- if self.shuffle:
- for bucket in self.buckets:
- indices.append(torch.randperm(len(bucket), generator=g).tolist())
- else:
- for bucket in self.buckets:
- indices.append(list(range(len(bucket))))
-
- batches = []
- for i in range(len(self.buckets)):
- bucket = self.buckets[i]
- len_bucket = len(bucket)
- ids_bucket = indices[i]
- num_samples_bucket = self.num_samples_per_bucket[i]
-
- # add extra samples to make it evenly divisible
- rem = num_samples_bucket - len_bucket
- ids_bucket = (
- ids_bucket
- + ids_bucket * (rem // len_bucket)
- + ids_bucket[: (rem % len_bucket)]
- )
-
- # subsample
- ids_bucket = ids_bucket[self.rank :: self.num_replicas]
-
- # batching
- for j in range(len(ids_bucket) // self.batch_size):
- batch = [
- bucket[idx]
- for idx in ids_bucket[
- j * self.batch_size : (j + 1) * self.batch_size
- ]
- ]
- batches.append(batch)
-
- if self.shuffle:
- batch_ids = torch.randperm(len(batches), generator=g).tolist()
- batches = [batches[i] for i in batch_ids]
- self.batches = batches
-
- assert len(self.batches) * self.batch_size == self.num_samples
- return iter(self.batches)
-
- def _bisect(self, x, lo=0, hi=None):
- if hi is None:
- hi = len(self.boundaries) - 1
-
- if hi > lo:
- mid = (hi + lo) // 2
- if self.boundaries[mid] < x and x <= self.boundaries[mid + 1]:
- return mid
- elif x <= self.boundaries[mid]:
- return self._bisect(x, lo, mid)
- else:
- return self._bisect(x, mid + 1, hi)
- else:
- return -1
-
- def __len__(self):
- return self.num_samples // self.batch_size
diff --git a/spaces/SkyYeXianer/vits-uma-genshin-honkai/modules.py b/spaces/SkyYeXianer/vits-uma-genshin-honkai/modules.py
deleted file mode 100644
index 56ea4145eddf19dd330a3a41ab0183efc1686d83..0000000000000000000000000000000000000000
--- a/spaces/SkyYeXianer/vits-uma-genshin-honkai/modules.py
+++ /dev/null
@@ -1,388 +0,0 @@
-import math
-import numpy as np
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm
-
-import commons
-from commons import init_weights, get_padding
-from transforms import piecewise_rational_quadratic_transform
-
-
-LRELU_SLOPE = 0.1
-
-
-class LayerNorm(nn.Module):
- def __init__(self, channels, eps=1e-5):
- super().__init__()
- self.channels = channels
- self.eps = eps
-
- self.gamma = nn.Parameter(torch.ones(channels))
- self.beta = nn.Parameter(torch.zeros(channels))
-
- def forward(self, x):
- x = x.transpose(1, -1)
- x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
- return x.transpose(1, -1)
-
-
-class ConvReluNorm(nn.Module):
- def __init__(self, in_channels, hidden_channels, out_channels, kernel_size, n_layers, p_dropout):
- super().__init__()
- self.in_channels = in_channels
- self.hidden_channels = hidden_channels
- self.out_channels = out_channels
- self.kernel_size = kernel_size
- self.n_layers = n_layers
- self.p_dropout = p_dropout
- assert n_layers > 1, "Number of layers should be larger than 0."
-
- self.conv_layers = nn.ModuleList()
- self.norm_layers = nn.ModuleList()
- self.conv_layers.append(nn.Conv1d(in_channels, hidden_channels, kernel_size, padding=kernel_size//2))
- self.norm_layers.append(LayerNorm(hidden_channels))
- self.relu_drop = nn.Sequential(
- nn.ReLU(),
- nn.Dropout(p_dropout))
- for _ in range(n_layers-1):
- self.conv_layers.append(nn.Conv1d(hidden_channels, hidden_channels, kernel_size, padding=kernel_size//2))
- self.norm_layers.append(LayerNorm(hidden_channels))
- self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
- self.proj.weight.data.zero_()
- self.proj.bias.data.zero_()
-
- def forward(self, x, x_mask):
- x_org = x
- for i in range(self.n_layers):
- x = self.conv_layers[i](x * x_mask)
- x = self.norm_layers[i](x)
- x = self.relu_drop(x)
- x = x_org + self.proj(x)
- return x * x_mask
-
-
-class DDSConv(nn.Module):
- """
- Dialted and Depth-Separable Convolution
- """
- def __init__(self, channels, kernel_size, n_layers, p_dropout=0.):
- super().__init__()
- self.channels = channels
- self.kernel_size = kernel_size
- self.n_layers = n_layers
- self.p_dropout = p_dropout
-
- self.drop = nn.Dropout(p_dropout)
- self.convs_sep = nn.ModuleList()
- self.convs_1x1 = nn.ModuleList()
- self.norms_1 = nn.ModuleList()
- self.norms_2 = nn.ModuleList()
- for i in range(n_layers):
- dilation = kernel_size ** i
- padding = (kernel_size * dilation - dilation) // 2
- self.convs_sep.append(nn.Conv1d(channels, channels, kernel_size,
- groups=channels, dilation=dilation, padding=padding
- ))
- self.convs_1x1.append(nn.Conv1d(channels, channels, 1))
- self.norms_1.append(LayerNorm(channels))
- self.norms_2.append(LayerNorm(channels))
-
- def forward(self, x, x_mask, g=None):
- if g is not None:
- x = x + g
- for i in range(self.n_layers):
- y = self.convs_sep[i](x * x_mask)
- y = self.norms_1[i](y)
- y = F.gelu(y)
- y = self.convs_1x1[i](y)
- y = self.norms_2[i](y)
- y = F.gelu(y)
- y = self.drop(y)
- x = x + y
- return x * x_mask
-
-
-class WN(torch.nn.Module):
- def __init__(self, hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=0, p_dropout=0):
- super(WN, self).__init__()
- assert(kernel_size % 2 == 1)
- self.hidden_channels =hidden_channels
- self.kernel_size = kernel_size,
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.gin_channels = gin_channels
- self.p_dropout = p_dropout
-
- self.in_layers = torch.nn.ModuleList()
- self.res_skip_layers = torch.nn.ModuleList()
- self.drop = nn.Dropout(p_dropout)
-
- if gin_channels != 0:
- cond_layer = torch.nn.Conv1d(gin_channels, 2*hidden_channels*n_layers, 1)
- self.cond_layer = torch.nn.utils.weight_norm(cond_layer, name='weight')
-
- for i in range(n_layers):
- dilation = dilation_rate ** i
- padding = int((kernel_size * dilation - dilation) / 2)
- in_layer = torch.nn.Conv1d(hidden_channels, 2*hidden_channels, kernel_size,
- dilation=dilation, padding=padding)
- in_layer = torch.nn.utils.weight_norm(in_layer, name='weight')
- self.in_layers.append(in_layer)
-
- # last one is not necessary
- if i < n_layers - 1:
- res_skip_channels = 2 * hidden_channels
- else:
- res_skip_channels = hidden_channels
-
- res_skip_layer = torch.nn.Conv1d(hidden_channels, res_skip_channels, 1)
- res_skip_layer = torch.nn.utils.weight_norm(res_skip_layer, name='weight')
- self.res_skip_layers.append(res_skip_layer)
-
- def forward(self, x, x_mask, g=None, **kwargs):
- output = torch.zeros_like(x)
- n_channels_tensor = torch.IntTensor([self.hidden_channels])
-
- if g is not None:
- g = self.cond_layer(g)
-
- for i in range(self.n_layers):
- x_in = self.in_layers[i](x)
- if g is not None:
- cond_offset = i * 2 * self.hidden_channels
- g_l = g[:,cond_offset:cond_offset+2*self.hidden_channels,:]
- else:
- g_l = torch.zeros_like(x_in)
-
- acts = commons.fused_add_tanh_sigmoid_multiply(
- x_in,
- g_l,
- n_channels_tensor)
- acts = self.drop(acts)
-
- res_skip_acts = self.res_skip_layers[i](acts)
- if i < self.n_layers - 1:
- res_acts = res_skip_acts[:,:self.hidden_channels,:]
- x = (x + res_acts) * x_mask
- output = output + res_skip_acts[:,self.hidden_channels:,:]
- else:
- output = output + res_skip_acts
- return output * x_mask
-
- def remove_weight_norm(self):
- if self.gin_channels != 0:
- torch.nn.utils.remove_weight_norm(self.cond_layer)
- for l in self.in_layers:
- torch.nn.utils.remove_weight_norm(l)
- for l in self.res_skip_layers:
- torch.nn.utils.remove_weight_norm(l)
-
-
-class ResBlock1(torch.nn.Module):
- def __init__(self, channels, kernel_size=3, dilation=(1, 3, 5)):
- super(ResBlock1, self).__init__()
- self.convs1 = nn.ModuleList([
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
- padding=get_padding(kernel_size, dilation[0]))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
- padding=get_padding(kernel_size, dilation[1]))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[2],
- padding=get_padding(kernel_size, dilation[2])))
- ])
- self.convs1.apply(init_weights)
-
- self.convs2 = nn.ModuleList([
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
- padding=get_padding(kernel_size, 1))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
- padding=get_padding(kernel_size, 1))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
- padding=get_padding(kernel_size, 1)))
- ])
- self.convs2.apply(init_weights)
-
- def forward(self, x, x_mask=None):
- for c1, c2 in zip(self.convs1, self.convs2):
- xt = F.leaky_relu(x, LRELU_SLOPE)
- if x_mask is not None:
- xt = xt * x_mask
- xt = c1(xt)
- xt = F.leaky_relu(xt, LRELU_SLOPE)
- if x_mask is not None:
- xt = xt * x_mask
- xt = c2(xt)
- x = xt + x
- if x_mask is not None:
- x = x * x_mask
- return x
-
- def remove_weight_norm(self):
- for l in self.convs1:
- remove_weight_norm(l)
- for l in self.convs2:
- remove_weight_norm(l)
-
-
-class ResBlock2(torch.nn.Module):
- def __init__(self, channels, kernel_size=3, dilation=(1, 3)):
- super(ResBlock2, self).__init__()
- self.convs = nn.ModuleList([
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
- padding=get_padding(kernel_size, dilation[0]))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
- padding=get_padding(kernel_size, dilation[1])))
- ])
- self.convs.apply(init_weights)
-
- def forward(self, x, x_mask=None):
- for c in self.convs:
- xt = F.leaky_relu(x, LRELU_SLOPE)
- if x_mask is not None:
- xt = xt * x_mask
- xt = c(xt)
- x = xt + x
- if x_mask is not None:
- x = x * x_mask
- return x
-
- def remove_weight_norm(self):
- for l in self.convs:
- remove_weight_norm(l)
-
-
-class Log(nn.Module):
- def forward(self, x, x_mask, reverse=False, **kwargs):
- if not reverse:
- y = torch.log(torch.clamp_min(x, 1e-5)) * x_mask
- logdet = torch.sum(-y, [1, 2])
- return y, logdet
- else:
- x = torch.exp(x) * x_mask
- return x
-
-
-class Flip(nn.Module):
- def forward(self, x, *args, reverse=False, **kwargs):
- x = torch.flip(x, [1])
- if not reverse:
- logdet = torch.zeros(x.size(0)).to(dtype=x.dtype, device=x.device)
- return x, logdet
- else:
- return x
-
-
-class ElementwiseAffine(nn.Module):
- def __init__(self, channels):
- super().__init__()
- self.channels = channels
- self.m = nn.Parameter(torch.zeros(channels,1))
- self.logs = nn.Parameter(torch.zeros(channels,1))
-
- def forward(self, x, x_mask, reverse=False, **kwargs):
- if not reverse:
- y = self.m + torch.exp(self.logs) * x
- y = y * x_mask
- logdet = torch.sum(self.logs * x_mask, [1,2])
- return y, logdet
- else:
- x = (x - self.m) * torch.exp(-self.logs) * x_mask
- return x
-
-
-class ResidualCouplingLayer(nn.Module):
- def __init__(self,
- channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- p_dropout=0,
- gin_channels=0,
- mean_only=False):
- assert channels % 2 == 0, "channels should be divisible by 2"
- super().__init__()
- self.channels = channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.half_channels = channels // 2
- self.mean_only = mean_only
-
- self.pre = nn.Conv1d(self.half_channels, hidden_channels, 1)
- self.enc = WN(hidden_channels, kernel_size, dilation_rate, n_layers, p_dropout=p_dropout, gin_channels=gin_channels)
- self.post = nn.Conv1d(hidden_channels, self.half_channels * (2 - mean_only), 1)
- self.post.weight.data.zero_()
- self.post.bias.data.zero_()
-
- def forward(self, x, x_mask, g=None, reverse=False):
- x0, x1 = torch.split(x, [self.half_channels]*2, 1)
- h = self.pre(x0) * x_mask
- h = self.enc(h, x_mask, g=g)
- stats = self.post(h) * x_mask
- if not self.mean_only:
- m, logs = torch.split(stats, [self.half_channels]*2, 1)
- else:
- m = stats
- logs = torch.zeros_like(m)
-
- if not reverse:
- x1 = m + x1 * torch.exp(logs) * x_mask
- x = torch.cat([x0, x1], 1)
- logdet = torch.sum(logs, [1,2])
- return x, logdet
- else:
- x1 = (x1 - m) * torch.exp(-logs) * x_mask
- x = torch.cat([x0, x1], 1)
- return x
-
-
-class ConvFlow(nn.Module):
- def __init__(self, in_channels, filter_channels, kernel_size, n_layers, num_bins=10, tail_bound=5.0):
- super().__init__()
- self.in_channels = in_channels
- self.filter_channels = filter_channels
- self.kernel_size = kernel_size
- self.n_layers = n_layers
- self.num_bins = num_bins
- self.tail_bound = tail_bound
- self.half_channels = in_channels // 2
-
- self.pre = nn.Conv1d(self.half_channels, filter_channels, 1)
- self.convs = DDSConv(filter_channels, kernel_size, n_layers, p_dropout=0.)
- self.proj = nn.Conv1d(filter_channels, self.half_channels * (num_bins * 3 - 1), 1)
- self.proj.weight.data.zero_()
- self.proj.bias.data.zero_()
-
- def forward(self, x, x_mask, g=None, reverse=False):
- x0, x1 = torch.split(x, [self.half_channels]*2, 1)
- h = self.pre(x0)
- h = self.convs(h, x_mask, g=g)
- h = self.proj(h) * x_mask
-
- b, c, t = x0.shape
- h = h.reshape(b, c, -1, t).permute(0, 1, 3, 2) # [b, cx?, t] -> [b, c, t, ?]
-
- unnormalized_widths = h[..., :self.num_bins] / math.sqrt(self.filter_channels)
- unnormalized_heights = h[..., self.num_bins:2*self.num_bins] / math.sqrt(self.filter_channels)
- unnormalized_derivatives = h[..., 2 * self.num_bins:]
-
- x1, logabsdet = piecewise_rational_quadratic_transform(x1,
- unnormalized_widths,
- unnormalized_heights,
- unnormalized_derivatives,
- inverse=reverse,
- tails='linear',
- tail_bound=self.tail_bound
- )
-
- x = torch.cat([x0, x1], 1) * x_mask
- logdet = torch.sum(logabsdet * x_mask, [1,2])
- if not reverse:
- return x, logdet
- else:
- return x
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/IPython/utils/tests/test_tokenutil.py b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/IPython/utils/tests/test_tokenutil.py
deleted file mode 100644
index c4539d1fc7e330bfcde2086562c10f0f03161402..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/IPython/utils/tests/test_tokenutil.py
+++ /dev/null
@@ -1,141 +0,0 @@
-"""Tests for tokenutil"""
-# Copyright (c) IPython Development Team.
-# Distributed under the terms of the Modified BSD License.
-
-import pytest
-
-from IPython.utils.tokenutil import token_at_cursor, line_at_cursor
-
-def expect_token(expected, cell, cursor_pos):
- token = token_at_cursor(cell, cursor_pos)
- offset = 0
- for line in cell.splitlines():
- if offset + len(line) >= cursor_pos:
- break
- else:
- offset += len(line)+1
- column = cursor_pos - offset
- line_with_cursor = "%s|%s" % (line[:column], line[column:])
- assert token == expected, "Expected %r, got %r in: %r (pos %i)" % (
- expected,
- token,
- line_with_cursor,
- cursor_pos,
- )
-
-
-def test_simple():
- cell = "foo"
- for i in range(len(cell)):
- expect_token("foo", cell, i)
-
-def test_function():
- cell = "foo(a=5, b='10')"
- expected = 'foo'
- # up to `foo(|a=`
- for i in range(cell.find('a=') + 1):
- expect_token("foo", cell, i)
- # find foo after `=`
- for i in [cell.find('=') + 1, cell.rfind('=') + 1]:
- expect_token("foo", cell, i)
- # in between `5,|` and `|b=`
- for i in range(cell.find(','), cell.find('b=')):
- expect_token("foo", cell, i)
-
-def test_multiline():
- cell = '\n'.join([
- 'a = 5',
- 'b = hello("string", there)'
- ])
- expected = 'hello'
- start = cell.index(expected) + 1
- for i in range(start, start + len(expected)):
- expect_token(expected, cell, i)
- expected = 'hello'
- start = cell.index(expected) + 1
- for i in range(start, start + len(expected)):
- expect_token(expected, cell, i)
-
-def test_multiline_token():
- cell = '\n'.join([
- '"""\n\nxxxxxxxxxx\n\n"""',
- '5, """',
- 'docstring',
- 'multiline token',
- '""", [',
- '2, 3, "complicated"]',
- 'b = hello("string", there)'
- ])
- expected = 'hello'
- start = cell.index(expected) + 1
- for i in range(start, start + len(expected)):
- expect_token(expected, cell, i)
- expected = 'hello'
- start = cell.index(expected) + 1
- for i in range(start, start + len(expected)):
- expect_token(expected, cell, i)
-
-def test_nested_call():
- cell = "foo(bar(a=5), b=10)"
- expected = 'foo'
- start = cell.index('bar') + 1
- for i in range(start, start + 3):
- expect_token(expected, cell, i)
- expected = 'bar'
- start = cell.index('a=')
- for i in range(start, start + 3):
- expect_token(expected, cell, i)
- expected = 'foo'
- start = cell.index(')') + 1
- for i in range(start, len(cell)-1):
- expect_token(expected, cell, i)
-
-def test_attrs():
- cell = "a = obj.attr.subattr"
- expected = 'obj'
- idx = cell.find('obj') + 1
- for i in range(idx, idx + 3):
- expect_token(expected, cell, i)
- idx = cell.find('.attr') + 2
- expected = 'obj.attr'
- for i in range(idx, idx + 4):
- expect_token(expected, cell, i)
- idx = cell.find('.subattr') + 2
- expected = 'obj.attr.subattr'
- for i in range(idx, len(cell)):
- expect_token(expected, cell, i)
-
-def test_line_at_cursor():
- cell = ""
- (line, offset) = line_at_cursor(cell, cursor_pos=11)
- assert line == ""
- assert offset == 0
-
- # The position after a newline should be the start of the following line.
- cell = "One\nTwo\n"
- (line, offset) = line_at_cursor(cell, cursor_pos=4)
- assert line == "Two\n"
- assert offset == 4
-
- # The end of a cell should be on the last line
- cell = "pri\npri"
- (line, offset) = line_at_cursor(cell, cursor_pos=7)
- assert line == "pri"
- assert offset == 4
-
-
-@pytest.mark.parametrize(
- "c, token",
- zip(
- list(range(16, 22)) + list(range(22, 28)),
- ["int"] * (22 - 16) + ["map"] * (28 - 22),
- ),
-)
-def test_multiline_statement(c, token):
- cell = """a = (1,
- 3)
-
-int()
-map()
-"""
- expect_token(token, cell, c)
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/altair/vegalite/__init__.py b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/altair/vegalite/__init__.py
deleted file mode 100644
index 690d64e63bc40a6006318cd70535017d41643def..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/altair/vegalite/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-# ruff: noqa
-from .v5 import *
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/chromadb/test/db/migrations/00001-migration-1.sqlite.sql b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/chromadb/test/db/migrations/00001-migration-1.sqlite.sql
deleted file mode 100644
index a214bae8d5b0d6482fedd18265d4dfc756d47485..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/chromadb/test/db/migrations/00001-migration-1.sqlite.sql
+++ /dev/null
@@ -1,3 +0,0 @@
-CREATE TABLE table1 (
- name TEXT PRIMARY KEY
-);
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/chromadb/test/property/strategies.py b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/chromadb/test/property/strategies.py
deleted file mode 100644
index b082e033d49f451f806eae9887026914a9e74413..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/chromadb/test/property/strategies.py
+++ /dev/null
@@ -1,545 +0,0 @@
-import hashlib
-import hypothesis
-import hypothesis.strategies as st
-from typing import Any, Optional, List, Dict, Union
-from typing_extensions import TypedDict
-import numpy as np
-import numpy.typing as npt
-import chromadb.api.types as types
-import re
-from hypothesis.strategies._internal.strategies import SearchStrategy
-from hypothesis.errors import InvalidDefinition
-from hypothesis.stateful import RuleBasedStateMachine
-
-from dataclasses import dataclass
-
-from chromadb.api.types import Documents, Embeddings, Metadata
-
-# Set the random seed for reproducibility
-np.random.seed(0) # unnecessary, hypothesis does this for us
-
-# See Hypothesis documentation for creating strategies at
-# https://hypothesis.readthedocs.io/en/latest/data.html
-
-# NOTE: Because these strategies are used in state machines, we need to
-# work around an issue with state machines, in which strategies that frequently
-# are marked as invalid (i.e. through the use of `assume` or `.filter`) can cause the
-# state machine tests to fail with an hypothesis.errors.Unsatisfiable.
-
-# Ultimately this is because the entire state machine is run as a single Hypothesis
-# example, which ends up drawing from the same strategies an enormous number of times.
-# Whenever a strategy marks itself as invalid, Hypothesis tries to start the entire
-# state machine run over. See https://github.com/HypothesisWorks/hypothesis/issues/3618
-
-# Because strategy generation is all interrelated, seemingly small changes (especially
-# ones called early in a test) can have an outside effect. Generating lists with
-# unique=True, or dictionaries with a min size seems especially bad.
-
-# Please make changes to these strategies incrementally, testing to make sure they don't
-# start generating unsatisfiable examples.
-
-test_hnsw_config = {
- "hnsw:construction_ef": 128,
- "hnsw:search_ef": 128,
- "hnsw:M": 128,
-}
-
-
-class RecordSet(TypedDict):
- """
- A generated set of embeddings, ids, metadatas, and documents that
- represent what a user would pass to the API.
- """
-
- ids: Union[types.ID, List[types.ID]]
- embeddings: Optional[Union[types.Embeddings, types.Embedding]]
- metadatas: Optional[Union[List[types.Metadata], types.Metadata]]
- documents: Optional[Union[List[types.Document], types.Document]]
-
-
-class NormalizedRecordSet(TypedDict):
- """
- A RecordSet, with all fields normalized to lists.
- """
-
- ids: List[types.ID]
- embeddings: Optional[types.Embeddings]
- metadatas: Optional[List[types.Metadata]]
- documents: Optional[List[types.Document]]
-
-
-class StateMachineRecordSet(TypedDict):
- """
- Represents the internal state of a state machine in hypothesis tests.
- """
-
- ids: List[types.ID]
- embeddings: types.Embeddings
- metadatas: List[Optional[types.Metadata]]
- documents: List[Optional[types.Document]]
-
-
-class Record(TypedDict):
- """
- A single generated record.
- """
-
- id: types.ID
- embedding: Optional[types.Embedding]
- metadata: Optional[types.Metadata]
- document: Optional[types.Document]
-
-
-# TODO: support arbitrary text everywhere so we don't SQL-inject ourselves.
-# TODO: support empty strings everywhere
-sql_alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_"
-safe_text = st.text(alphabet=sql_alphabet, min_size=1)
-
-# Workaround for FastAPI json encoding peculiarities
-# https://github.com/tiangolo/fastapi/blob/8ac8d70d52bb0dd9eb55ba4e22d3e383943da05c/fastapi/encoders.py#L104
-safe_text = safe_text.filter(lambda s: not s.startswith("_sa"))
-
-safe_integers = st.integers(
- min_value=-(2**31), max_value=2**31 - 1
-) # TODO: handle longs
-safe_floats = st.floats(
- allow_infinity=False,
- allow_nan=False,
- allow_subnormal=False,
- min_value=-1e6,
- max_value=1e6,
-) # TODO: handle infinity and NAN
-
-safe_values: List[SearchStrategy[Union[int, float, str]]] = [
- safe_text,
- safe_integers,
- safe_floats,
-]
-
-
-def one_or_both(
- strategy_a: st.SearchStrategy[Any], strategy_b: st.SearchStrategy[Any]
-) -> st.SearchStrategy[Any]:
- return st.one_of(
- st.tuples(strategy_a, strategy_b),
- st.tuples(strategy_a, st.none()),
- st.tuples(st.none(), strategy_b),
- )
-
-
-# Temporarily generate only these to avoid SQL formatting issues.
-legal_id_characters = (
- "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_./+"
-)
-
-float_types = [np.float16, np.float32, np.float64]
-int_types = [np.int16, np.int32, np.int64] # TODO: handle int types
-
-
-@st.composite
-def collection_name(draw: st.DrawFn) -> str:
- _collection_name_re = re.compile(r"^[a-zA-Z][a-zA-Z0-9-]{1,60}[a-zA-Z0-9]$")
- _ipv4_address_re = re.compile(r"^([0-9]{1,3}\.){3}[0-9]{1,3}$")
- _two_periods_re = re.compile(r"\.\.")
-
- name: str = draw(st.from_regex(_collection_name_re))
- hypothesis.assume(not _ipv4_address_re.match(name))
- hypothesis.assume(not _two_periods_re.search(name))
-
- return name
-
-
-collection_metadata = st.one_of(
- st.none(), st.dictionaries(safe_text, st.one_of(*safe_values))
-)
-
-
-# TODO: Use a hypothesis strategy while maintaining embedding uniqueness
-# Or handle duplicate embeddings within a known epsilon
-def create_embeddings(
- dim: int,
- count: int,
- dtype: npt.DTypeLike,
-) -> types.Embeddings:
- embeddings: types.Embeddings = (
- np.random.uniform(
- low=-1.0,
- high=1.0,
- size=(count, dim),
- )
- .astype(dtype)
- .tolist()
- )
-
- return embeddings
-
-
-class hashing_embedding_function(types.EmbeddingFunction):
- def __init__(self, dim: int, dtype: npt.DTypeLike) -> None:
- self.dim = dim
- self.dtype = dtype
-
- def __call__(self, texts: types.Documents) -> types.Embeddings:
- # Hash the texts and convert to hex strings
- hashed_texts = [
- list(hashlib.sha256(text.encode("utf-8")).hexdigest()) for text in texts
- ]
- # Pad with repetition, or truncate the hex strings to the desired dimension
- padded_texts = [
- text * (self.dim // len(text)) + text[: self.dim % len(text)]
- for text in hashed_texts
- ]
-
- # Convert the hex strings to dtype
- embeddings: types.Embeddings = np.array(
- [[int(char, 16) / 15.0 for char in text] for text in padded_texts],
- dtype=self.dtype,
- ).tolist()
-
- return embeddings
-
-
-class not_implemented_embedding_function(types.EmbeddingFunction):
- def __call__(self, texts: Documents) -> Embeddings:
- assert False, "This embedding function is not implemented"
-
-
-def embedding_function_strategy(
- dim: int, dtype: npt.DTypeLike
-) -> st.SearchStrategy[types.EmbeddingFunction]:
- return st.just(hashing_embedding_function(dim, dtype))
-
-
-@dataclass
-class Collection:
- name: str
- metadata: Optional[types.Metadata]
- dimension: int
- dtype: npt.DTypeLike
- known_metadata_keys: types.Metadata
- known_document_keywords: List[str]
- has_documents: bool = False
- has_embeddings: bool = False
- embedding_function: Optional[types.EmbeddingFunction] = None
-
-
-@st.composite
-def collections(
- draw: st.DrawFn,
- add_filterable_data: bool = False,
- with_hnsw_params: bool = False,
- has_embeddings: Optional[bool] = None,
- has_documents: Optional[bool] = None,
-) -> Collection:
- """Strategy to generate a Collection object. If add_filterable_data is True, then known_metadata_keys and known_document_keywords will be populated with consistent data."""
-
- assert not ((has_embeddings is False) and (has_documents is False))
-
- name = draw(collection_name())
- metadata = draw(collection_metadata)
- dimension = draw(st.integers(min_value=2, max_value=2048))
- dtype = draw(st.sampled_from(float_types))
-
- if with_hnsw_params:
- if metadata is None:
- metadata = {}
- metadata.update(test_hnsw_config)
- # Sometimes, select a space at random
- if draw(st.booleans()):
- # TODO: pull the distance functions from a source of truth that lives not
- # in tests once https://github.com/chroma-core/issues/issues/61 lands
- metadata["hnsw:space"] = draw(st.sampled_from(["cosine", "l2", "ip"]))
-
- known_metadata_keys: Dict[str, Union[int, str, float]] = {}
- if add_filterable_data:
- while len(known_metadata_keys) < 5:
- key = draw(safe_text)
- known_metadata_keys[key] = draw(st.one_of(*safe_values))
-
- if has_documents is None:
- has_documents = draw(st.booleans())
- assert has_documents is not None
- if has_documents and add_filterable_data:
- known_document_keywords = draw(st.lists(safe_text, min_size=5, max_size=5))
- else:
- known_document_keywords = []
-
- if not has_documents:
- has_embeddings = True
- else:
- if has_embeddings is None:
- has_embeddings = draw(st.booleans())
- assert has_embeddings is not None
-
- embedding_function = draw(embedding_function_strategy(dimension, dtype))
-
- return Collection(
- name=name,
- metadata=metadata,
- dimension=dimension,
- dtype=dtype,
- known_metadata_keys=known_metadata_keys,
- has_documents=has_documents,
- known_document_keywords=known_document_keywords,
- has_embeddings=has_embeddings,
- embedding_function=embedding_function,
- )
-
-
-@st.composite
-def metadata(draw: st.DrawFn, collection: Collection) -> types.Metadata:
- """Strategy for generating metadata that could be a part of the given collection"""
- # First draw a random dictionary.
- metadata: types.Metadata = draw(st.dictionaries(safe_text, st.one_of(*safe_values)))
- # Then, remove keys that overlap with the known keys for the coll
- # to avoid type errors when comparing.
- if collection.known_metadata_keys:
- for key in collection.known_metadata_keys.keys():
- if key in metadata:
- del metadata[key]
- # Finally, add in some of the known keys for the collection
- sampling_dict: Dict[str, st.SearchStrategy[Union[str, int, float]]] = {
- k: st.just(v) for k, v in collection.known_metadata_keys.items()
- }
- metadata.update(draw(st.fixed_dictionaries({}, optional=sampling_dict)))
- return metadata
-
-
-@st.composite
-def document(draw: st.DrawFn, collection: Collection) -> types.Document:
- """Strategy for generating documents that could be a part of the given collection"""
-
- if collection.known_document_keywords:
- known_words_st = st.sampled_from(collection.known_document_keywords)
- else:
- known_words_st = st.text(min_size=1)
-
- random_words_st = st.text(min_size=1)
- words = draw(st.lists(st.one_of(known_words_st, random_words_st), min_size=1))
- return " ".join(words)
-
-
-@st.composite
-def recordsets(
- draw: st.DrawFn,
- collection_strategy: SearchStrategy[Collection] = collections(),
- id_strategy: SearchStrategy[str] = safe_text,
- min_size: int = 1,
- max_size: int = 50,
-) -> RecordSet:
- collection = draw(collection_strategy)
-
- ids = list(
- draw(st.lists(id_strategy, min_size=min_size, max_size=max_size, unique=True))
- )
-
- embeddings: Optional[Embeddings] = None
- if collection.has_embeddings:
- embeddings = create_embeddings(collection.dimension, len(ids), collection.dtype)
- metadatas = draw(
- st.lists(metadata(collection), min_size=len(ids), max_size=len(ids))
- )
- documents: Optional[Documents] = None
- if collection.has_documents:
- documents = draw(
- st.lists(document(collection), min_size=len(ids), max_size=len(ids))
- )
-
- # in the case where we have a single record, sometimes exercise
- # the code that handles individual values rather than lists.
- # In this case, any field may be a list or a single value.
- if len(ids) == 1:
- single_id: Union[str, List[str]] = ids[0] if draw(st.booleans()) else ids
- single_embedding = (
- embeddings[0]
- if embeddings is not None and draw(st.booleans())
- else embeddings
- )
- single_metadata: Union[Metadata, List[Metadata]] = (
- metadatas[0] if draw(st.booleans()) else metadatas
- )
- single_document = (
- documents[0] if documents is not None and draw(st.booleans()) else documents
- )
- return {
- "ids": single_id,
- "embeddings": single_embedding,
- "metadatas": single_metadata,
- "documents": single_document,
- }
-
- return {
- "ids": ids,
- "embeddings": embeddings,
- "metadatas": metadatas,
- "documents": documents,
- }
-
-
-# This class is mostly cloned from from hypothesis.stateful.RuleStrategy,
-# but always runs all the rules, instead of using a FeatureStrategy to
-# enable/disable rules. Disabled rules cause the entire test to be marked invalida and,
-# combined with the complexity of our other strategies, leads to an
-# unacceptably increased incidence of hypothesis.errors.Unsatisfiable.
-class DeterministicRuleStrategy(SearchStrategy): # type: ignore
- def __init__(self, machine: RuleBasedStateMachine) -> None:
- super().__init__() # type: ignore
- self.machine = machine
- self.rules = list(machine.rules()) # type: ignore
-
- # The order is a bit arbitrary. Primarily we're trying to group rules
- # that write to the same location together, and to put rules with no
- # target first as they have less effect on the structure. We order from
- # fewer to more arguments on grounds that it will plausibly need less
- # data. This probably won't work especially well and we could be
- # smarter about it, but it's better than just doing it in definition
- # order.
- self.rules.sort(
- key=lambda rule: (
- sorted(rule.targets),
- len(rule.arguments),
- rule.function.__name__,
- )
- )
-
- def __repr__(self) -> str:
- return "{}(machine={}({{...}}))".format(
- self.__class__.__name__,
- self.machine.__class__.__name__,
- )
-
- def do_draw(self, data): # type: ignore
- if not any(self.is_valid(rule) for rule in self.rules):
- msg = f"No progress can be made from state {self.machine!r}"
- raise InvalidDefinition(msg) from None
-
- rule = data.draw(st.sampled_from([r for r in self.rules if self.is_valid(r)]))
- argdata = data.draw(rule.arguments_strategy)
- return (rule, argdata)
-
- def is_valid(self, rule) -> bool: # type: ignore
- if not all(precond(self.machine) for precond in rule.preconditions):
- return False
-
- for b in rule.bundles:
- bundle = self.machine.bundle(b.name) # type: ignore
- if not bundle:
- return False
- return True
-
-
-@st.composite
-def where_clause(draw: st.DrawFn, collection: Collection) -> types.Where:
- """Generate a filter that could be used in a query against the given collection"""
-
- known_keys = sorted(collection.known_metadata_keys.keys())
-
- key = draw(st.sampled_from(known_keys))
- value = collection.known_metadata_keys[key]
-
- legal_ops: List[Optional[str]] = [None, "$eq", "$ne"]
- if not isinstance(value, str):
- legal_ops.extend(["$gt", "$lt", "$lte", "$gte"])
- if isinstance(value, float):
- # Add or subtract a small number to avoid floating point rounding errors
- value = value + draw(st.sampled_from([1e-6, -1e-6]))
-
- op: types.WhereOperator = draw(st.sampled_from(legal_ops))
-
- if op is None:
- return {key: value}
- else:
- return {key: {op: value}}
-
-
-@st.composite
-def where_doc_clause(draw: st.DrawFn, collection: Collection) -> types.WhereDocument:
- """Generate a where_document filter that could be used against the given collection"""
- if collection.known_document_keywords:
- word = draw(st.sampled_from(collection.known_document_keywords))
- else:
- word = draw(safe_text)
- return {"$contains": word}
-
-
-def binary_operator_clause(
- base_st: SearchStrategy[types.Where],
-) -> SearchStrategy[types.Where]:
- op: SearchStrategy[types.LogicalOperator] = st.sampled_from(["$and", "$or"])
- return st.dictionaries(
- keys=op,
- values=st.lists(base_st, max_size=2, min_size=2),
- min_size=1,
- max_size=1,
- )
-
-
-def binary_document_operator_clause(
- base_st: SearchStrategy[types.WhereDocument],
-) -> SearchStrategy[types.WhereDocument]:
- op: SearchStrategy[types.LogicalOperator] = st.sampled_from(["$and", "$or"])
- return st.dictionaries(
- keys=op,
- values=st.lists(base_st, max_size=2, min_size=2),
- min_size=1,
- max_size=1,
- )
-
-
-@st.composite
-def recursive_where_clause(draw: st.DrawFn, collection: Collection) -> types.Where:
- base_st = where_clause(collection)
- where: types.Where = draw(st.recursive(base_st, binary_operator_clause))
- return where
-
-
-@st.composite
-def recursive_where_doc_clause(
- draw: st.DrawFn, collection: Collection
-) -> types.WhereDocument:
- base_st = where_doc_clause(collection)
- where: types.WhereDocument = draw(
- st.recursive(base_st, binary_document_operator_clause)
- )
- return where
-
-
-class Filter(TypedDict):
- where: Optional[types.Where]
- ids: Optional[Union[str, List[str]]]
- where_document: Optional[types.WhereDocument]
-
-
-@st.composite
-def filters(
- draw: st.DrawFn,
- collection_st: st.SearchStrategy[Collection],
- recordset_st: st.SearchStrategy[RecordSet],
- include_all_ids: bool = False,
-) -> Filter:
- collection = draw(collection_st)
- recordset = draw(recordset_st)
-
- where_clause = draw(st.one_of(st.none(), recursive_where_clause(collection)))
- where_document_clause = draw(
- st.one_of(st.none(), recursive_where_doc_clause(collection))
- )
-
- ids: Optional[Union[List[types.ID], types.ID]]
- # Record sets can be a value instead of a list of values if there is only one record
- if isinstance(recordset["ids"], str):
- ids = [recordset["ids"]]
- else:
- ids = recordset["ids"]
-
- if not include_all_ids:
- ids = draw(st.one_of(st.none(), st.lists(st.sampled_from(ids))))
- if ids is not None:
- # Remove duplicates since hypothesis samples with replacement
- ids = list(set(ids))
-
- # Test both the single value list and the unwrapped single value case
- if ids is not None and len(ids) == 1 and draw(st.booleans()):
- ids = ids[0]
-
- return {"where": where_clause, "where_document": where_document_clause, "ids": ids}
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/clickhouse_connect/datatypes/container.py b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/clickhouse_connect/datatypes/container.py
deleted file mode 100644
index a96d570970177c0ab91447d8411e4ec09a9994cb..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/clickhouse_connect/datatypes/container.py
+++ /dev/null
@@ -1,294 +0,0 @@
-import array
-import logging
-from typing import Sequence, Collection
-
-from clickhouse_connect.driver.insert import InsertContext
-from clickhouse_connect.driver.query import QueryContext
-from clickhouse_connect.driver.types import ByteSource
-from clickhouse_connect.json_impl import any_to_json
-from clickhouse_connect.datatypes.base import ClickHouseType, TypeDef
-from clickhouse_connect.driver.common import must_swap
-from clickhouse_connect.datatypes.registry import get_from_name
-
-
-logger = logging.getLogger(__name__)
-
-
-class Array(ClickHouseType):
- __slots__ = ('element_type',)
- python_type = list
-
- def __init__(self, type_def: TypeDef):
- super().__init__(type_def)
- self.element_type = get_from_name(type_def.values[0])
- self._name_suffix = f'({self.element_type.name})'
-
- def read_column_prefix(self, source: ByteSource):
- return self.element_type.read_column_prefix(source)
-
- def _data_size(self, sample: Sequence) -> int:
- if len(sample) == 0:
- return 8
- total = 0
- for x in sample:
- total += self.element_type.data_size(x)
- return total // len(sample) + 8
-
- # pylint: disable=too-many-locals
- def read_column_data(self, source: ByteSource, num_rows: int, ctx: QueryContext):
- final_type = self.element_type
- depth = 1
- while isinstance(final_type, Array):
- depth += 1
- final_type = final_type.element_type
- level_size = num_rows
- offset_sizes = []
- for _ in range(depth):
- level_offsets = source.read_array('Q', level_size)
- offset_sizes.append(level_offsets)
- level_size = level_offsets[-1] if level_offsets else 0
- if level_size:
- all_values = final_type.read_column_data(source, level_size, ctx)
- else:
- all_values = []
- column = all_values if isinstance(all_values, list) else list(all_values)
- for offset_range in reversed(offset_sizes):
- data = []
- last = 0
- for x in offset_range:
- data.append(column[last: x])
- last = x
- column = data
- return column
-
- def write_column_prefix(self, dest: bytearray):
- self.element_type.write_column_prefix(dest)
-
- def write_column_data(self, column: Sequence, dest: bytearray, ctx: InsertContext):
- final_type = self.element_type
- depth = 1
- while isinstance(final_type, Array):
- depth += 1
- final_type = final_type.element_type
- for _ in range(depth):
- total = 0
- data = []
- offsets = array.array('Q')
- for x in column:
- total += len(x)
- offsets.append(total)
- data.extend(x)
- if must_swap:
- offsets.byteswap()
- dest += offsets.tobytes()
- column = data
- final_type.write_column_data(column, dest, ctx)
-
-
-class Tuple(ClickHouseType):
- _slots = 'element_names', 'element_types'
- python_type = tuple
- valid_formats = 'tuple', 'json', 'native' # native is 'tuple' for unnamed tuples, and dict for named tuples
-
- def __init__(self, type_def: TypeDef):
- super().__init__(type_def)
- self.element_names = type_def.keys
- self.element_types = [get_from_name(name) for name in type_def.values]
- if self.element_names:
- self._name_suffix = f"({', '.join(k + ' ' + str(v) for k, v in zip(type_def.keys, type_def.values))})"
- else:
- self._name_suffix = type_def.arg_str
-
- def _data_size(self, sample: Collection) -> int:
- if len(sample) == 0:
- return 0
- elem_size = 0
- for ix, e_type in enumerate(self.element_types):
- if e_type.byte_size > 0:
- elem_size += e_type.byte_size
- else:
- elem_size += e_type.data_size([x[ix] for x in sample])
- return elem_size
-
- def read_column_prefix(self, source: ByteSource):
- for e_type in self.element_types:
- e_type.read_column_prefix(source)
-
- def read_column_data(self, source: ByteSource, num_rows: int, ctx: QueryContext):
- columns = []
- e_names = self.element_names
- for e_type in self.element_types:
- column = e_type.read_column_data(source, num_rows, ctx)
- columns.append(column)
- if e_names and self.read_format(ctx) != 'tuple':
- dicts = [{} for _ in range(num_rows)]
- for ix, x in enumerate(dicts):
- for y, key in enumerate(e_names):
- x[key] = columns[y][ix]
- if self.read_format(ctx) == 'json':
- to_json = any_to_json
- return [to_json(x) for x in dicts]
- return dicts
- return tuple(zip(*columns))
-
- def write_column_prefix(self, dest: bytearray):
- for e_type in self.element_types:
- e_type.write_column_prefix(dest)
-
- def write_column_data(self, column: Sequence, dest: bytearray, ctx: InsertContext):
- columns = list(zip(*column))
- for e_type, elem_column in zip(self.element_types, columns):
- e_type.write_column_data(elem_column, dest, ctx)
-
-
-class Map(ClickHouseType):
- _slots = 'key_type', 'value_type'
- python_type = dict
-
- def __init__(self, type_def: TypeDef):
- super().__init__(type_def)
- self.key_type = get_from_name(type_def.values[0])
- self.value_type = get_from_name(type_def.values[1])
- self._name_suffix = type_def.arg_str
-
- def _data_size(self, sample: Collection) -> int:
- total = 0
- if len(sample) == 0:
- return 0
- for x in sample:
- total += self.key_type.data_size(x.keys())
- total += self.value_type.data_size(x.values())
- return total // len(sample)
-
- def read_column_prefix(self, source: ByteSource):
- self.key_type.read_column_prefix(source)
- self.value_type.read_column_prefix(source)
-
- # pylint: disable=too-many-locals
- def read_column_data(self, source: ByteSource, num_rows: int, ctx: QueryContext):
- offsets = source.read_array('Q', num_rows)
- total_rows = offsets[-1]
- keys = self.key_type.read_column_data(source, total_rows, ctx)
- values = self.value_type.read_column_data(source, total_rows, ctx)
- all_pairs = tuple(zip(keys, values))
- column = []
- app = column.append
- last = 0
- for offset in offsets:
- app(dict(all_pairs[last: offset]))
- last = offset
- return column
-
- def write_column_prefix(self, dest: bytearray):
- self.key_type.write_column_prefix(dest)
- self.value_type.write_column_prefix(dest)
-
- def write_column_data(self, column: Sequence, dest: bytearray, ctx: InsertContext):
- offsets = array.array('Q')
- keys = []
- values = []
- total = 0
- for v in column:
- total += len(v)
- offsets.append(total)
- keys.extend(v.keys())
- values.extend(v.values())
- if must_swap:
- offsets.byteswap()
- dest += offsets.tobytes()
- self.key_type.write_column_data(keys, dest, ctx)
- self.value_type.write_column_data(values, dest, ctx)
-
-
-class Nested(ClickHouseType):
- __slots__ = 'tuple_array', 'element_names', 'element_types'
- python_type = Sequence[dict]
-
- def __init__(self, type_def):
- super().__init__(type_def)
- self.element_names = type_def.keys
- self.tuple_array = get_from_name(f"Array(Tuple({','.join(type_def.values)}))")
- self.element_types = self.tuple_array.element_type.element_types
- cols = [f'{x[0]} {x[1].name}' for x in zip(type_def.keys, self.element_types)]
- self._name_suffix = f"({', '.join(cols)})"
-
- def _data_size(self, sample: Collection) -> int:
- keys = self.element_names
- array_sample = [[tuple(sub_row[key] for key in keys) for sub_row in row] for row in sample]
- return self.tuple_array.data_size(array_sample)
-
- def read_column_prefix(self, source: ByteSource):
- self.tuple_array.read_column_prefix(source)
-
- def read_column_data(self, source: ByteSource, num_rows: int, ctx: QueryContext):
- keys = self.element_names
- data = self.tuple_array.read_column_data(source, num_rows, ctx)
- return [[dict(zip(keys, x)) for x in row] for row in data]
-
- def write_column_prefix(self, dest: bytearray):
- self.tuple_array.write_column_prefix(dest)
-
- def write_column_data(self, column: Sequence, dest: bytearray, ctx: InsertContext):
- keys = self.element_names
- data = [[tuple(sub_row[key] for key in keys) for sub_row in row] for row in column]
- self.tuple_array.write_column_data(data, dest, ctx)
-
-
-class JSON(ClickHouseType):
- python_type = dict
- # Native is a Python type (primitive, dict, array), string is an actual JSON string
- valid_formats = 'string', 'native'
-
- def write_column_prefix(self, dest: bytearray):
- dest.append(0x01)
-
- def _data_size(self, sample: Collection) -> int:
- if len(sample) == 0:
- return 0
- total = 0
- for x in sample:
- if isinstance(x, str):
- total += len(x)
- elif x:
- total += len(any_to_json(x))
- return total // len(sample) + 1
-
- # pylint: disable=duplicate-code
- def write_column_data(self, column: Sequence, dest: bytearray, ctx: InsertContext):
- app = dest.append
- first = self._first_value(column)
- if isinstance(first, str) or self.write_format(ctx) == 'string':
- for x in column:
- v = x.encode()
- sz = len(v)
- while True:
- b = sz & 0x7f
- sz >>= 7
- if sz == 0:
- app(b)
- break
- app(0x80 | b)
- dest += v
- else:
- to_json = any_to_json
- for x in column:
- v = to_json(x)
- sz = len(v)
- while True:
- b = sz & 0x7f
- sz >>= 7
- if sz == 0:
- app(b)
- break
- app(0x80 | b)
- dest += v
-
-
-class Object(JSON):
- python_type = dict
-
- def __init__(self, type_def):
- if type_def.values[0].lower() != "'json'":
- raise NotImplementedError('Only json Object type is currently supported')
- super().__init__(type_def)
- self._name_suffix = type_def.arg_str
diff --git a/spaces/Suniilkumaar/MusicGen-updated/audiocraft/modules/streaming.py b/spaces/Suniilkumaar/MusicGen-updated/audiocraft/modules/streaming.py
deleted file mode 100644
index fdbdf5e90fc0c6560873d66bf273460b38e5ed7e..0000000000000000000000000000000000000000
--- a/spaces/Suniilkumaar/MusicGen-updated/audiocraft/modules/streaming.py
+++ /dev/null
@@ -1,135 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-"""
-Streaming module API that should be implemented by all Streaming components,
-"""
-
-from contextlib import contextmanager
-import typing as tp
-from torch import nn
-import torch
-
-
-State = tp.Dict[str, torch.Tensor]
-
-
-class StreamingModule(nn.Module):
- """Common API for streaming components.
-
- Each streaming component has a streaming state, which is just a dict[str, Tensor].
- By convention, the first dim of each tensor must be the batch size.
- Don't use dots in the key names, as this would clash with submodules
- (like in state_dict).
-
- If `self._is_streaming` is True, the component should use and remember
- the proper state inside `self._streaming_state`.
-
- To set a streaming component in streaming state, use
-
- with module.streaming():
- ...
-
- This will automatically reset the streaming state when exiting the context manager.
- This also automatically propagates to all streaming children module.
-
- Some module might also implement the `StreamingModule.flush` method, although
- this one is trickier, as all parents module must be StreamingModule and implement
- it as well for it to work properly. See `StreamingSequential` after.
- """
- def __init__(self) -> None:
- super().__init__()
- self._streaming_state: State = {}
- self._is_streaming = False
-
- def _apply_named_streaming(self, fn: tp.Any):
- for name, module in self.named_modules():
- if isinstance(module, StreamingModule):
- fn(name, module)
-
- def _set_streaming(self, streaming: bool):
- def _set_streaming(name, module):
- module._is_streaming = streaming
- self._apply_named_streaming(_set_streaming)
-
- @contextmanager
- def streaming(self):
- """Context manager to enter streaming mode. Reset streaming state on exit.
- """
- self._set_streaming(True)
- try:
- yield
- finally:
- self._set_streaming(False)
- self.reset_streaming()
-
- def reset_streaming(self):
- """Reset the streaming state.
- """
- def _reset(name: str, module: StreamingModule):
- module._streaming_state.clear()
-
- self._apply_named_streaming(_reset)
-
- def get_streaming_state(self) -> State:
- """Return the streaming state, including that of sub-modules.
- """
- state: State = {}
-
- def _add(name: str, module: StreamingModule):
- if name:
- name += "."
- for key, value in module._streaming_state.items():
- state[name + key] = value
-
- self._apply_named_streaming(_add)
- return state
-
- def set_streaming_state(self, state: State):
- """Set the streaming state, including that of sub-modules.
- """
- state = dict(state)
-
- def _set(name: str, module: StreamingModule):
- if name:
- name += "."
- module._streaming_state.clear()
- for key, value in list(state.items()):
- # complexity is not ideal here, but probably fine.
- if key.startswith(name):
- local_key = key[len(name):]
- if '.' not in local_key:
- module._streaming_state[local_key] = value
- del state[key]
-
- self._apply_named_streaming(_set)
- assert len(state) == 0, list(state.keys())
-
- def flush(self, x: tp.Optional[torch.Tensor] = None):
- """Flush any remaining outputs that were waiting for completion.
- Typically, for convolutions, this will add the final padding
- and process the last buffer.
-
- This should take an optional argument `x`, which will be provided
- if a module before this one in the streaming pipeline has already
- spitted out a flushed out buffer.
- """
- if x is None:
- return None
- else:
- return self(x)
-
-
-class StreamingSequential(StreamingModule, nn.Sequential):
- """A streaming compatible alternative of `nn.Sequential`.
- """
- def flush(self, x: tp.Optional[torch.Tensor] = None):
- for module in self:
- if isinstance(module, StreamingModule):
- x = module.flush(x)
- elif x is not None:
- x = module(x)
- return x
diff --git a/spaces/Superlang/ImageProcessor/annotator/oneformer/oneformer/modeling/meta_arch/oneformer_head.py b/spaces/Superlang/ImageProcessor/annotator/oneformer/oneformer/modeling/meta_arch/oneformer_head.py
deleted file mode 100644
index f8f8eb11b95838d2b61de5fa249a318877182c01..0000000000000000000000000000000000000000
--- a/spaces/Superlang/ImageProcessor/annotator/oneformer/oneformer/modeling/meta_arch/oneformer_head.py
+++ /dev/null
@@ -1,135 +0,0 @@
-# ------------------------------------------------------------------------------
-# Reference: https://github.com/facebookresearch/Mask2Former/blob/main/mask2former/modeling/meta_arch/mask_former_head.py
-# Modified by Jitesh Jain (https://github.com/praeclarumjj3)
-# ------------------------------------------------------------------------------
-
-import logging
-from copy import deepcopy
-from typing import Callable, Dict, List, Optional, Tuple, Union
-
-import fvcore.nn.weight_init as weight_init
-from torch import nn
-from torch.nn import functional as F
-
-from annotator.oneformer.detectron2.config import configurable
-from annotator.oneformer.detectron2.layers import Conv2d, ShapeSpec, get_norm
-from annotator.oneformer.detectron2.modeling import SEM_SEG_HEADS_REGISTRY
-from ..pixel_decoder.fpn import build_pixel_decoder
-from ..transformer_decoder.oneformer_transformer_decoder import build_transformer_decoder
-
-@SEM_SEG_HEADS_REGISTRY.register()
-class OneFormerHead(nn.Module):
-
- _version = 2
-
- def _load_from_state_dict(
- self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs
- ):
- version = local_metadata.get("version", None)
- if version is None or version < 2:
- # Do not warn if train from scratch
- scratch = True
- logger = logging.getLogger(__name__)
- for k in list(state_dict.keys()):
- newk = k
- if "sem_seg_head" in k and not k.startswith(prefix + "predictor"):
- newk = k.replace(prefix, prefix + "pixel_decoder.")
- # logger.debug(f"{k} ==> {newk}")
- if newk != k:
- state_dict[newk] = state_dict[k]
- del state_dict[k]
- scratch = False
-
- if not scratch:
- logger.warning(
- f"Weight format of {self.__class__.__name__} have changed! "
- "Please upgrade your models. Applying automatic conversion now ..."
- )
-
- @configurable
- def __init__(
- self,
- input_shape: Dict[str, ShapeSpec],
- *,
- num_classes: int,
- pixel_decoder: nn.Module,
- loss_weight: float = 1.0,
- ignore_value: int = -1,
- # extra parameters
- transformer_predictor: nn.Module,
- transformer_in_feature: str,
- ):
- """
- NOTE: this interface is experimental.
- Args:
- input_shape: shapes (channels and stride) of the input features
- num_classes: number of classes to predict
- pixel_decoder: the pixel decoder module
- loss_weight: loss weight
- ignore_value: category id to be ignored during training.
- transformer_predictor: the transformer decoder that makes prediction
- transformer_in_feature: input feature name to the transformer_predictor
- """
- super().__init__()
- input_shape = sorted(input_shape.items(), key=lambda x: x[1].stride)
- self.in_features = [k for k, v in input_shape]
- feature_strides = [v.stride for k, v in input_shape]
- feature_channels = [v.channels for k, v in input_shape]
-
- self.ignore_value = ignore_value
- self.common_stride = 4
- self.loss_weight = loss_weight
-
- self.pixel_decoder = pixel_decoder
- self.predictor = transformer_predictor
- self.transformer_in_feature = transformer_in_feature
-
- self.num_classes = num_classes
-
- @classmethod
- def from_config(cls, cfg, input_shape: Dict[str, ShapeSpec]):
- # figure out in_channels to transformer predictor
- if cfg.MODEL.ONE_FORMER.TRANSFORMER_IN_FEATURE == "transformer_encoder":
- transformer_predictor_in_channels = cfg.MODEL.SEM_SEG_HEAD.CONVS_DIM
- elif cfg.MODEL.ONE_FORMER.TRANSFORMER_IN_FEATURE == "pixel_embedding":
- transformer_predictor_in_channels = cfg.MODEL.SEM_SEG_HEAD.MASK_DIM
- elif cfg.MODEL.ONE_FORMER.TRANSFORMER_IN_FEATURE == "multi_scale_pixel_decoder":
- transformer_predictor_in_channels = cfg.MODEL.SEM_SEG_HEAD.CONVS_DIM
- else:
- transformer_predictor_in_channels = input_shape[cfg.MODEL.ONE_FORMER.TRANSFORMER_IN_FEATURE].channels
-
- return {
- "input_shape": {
- k: v for k, v in input_shape.items() if k in cfg.MODEL.SEM_SEG_HEAD.IN_FEATURES
- },
- "ignore_value": cfg.MODEL.SEM_SEG_HEAD.IGNORE_VALUE,
- "num_classes": cfg.MODEL.SEM_SEG_HEAD.NUM_CLASSES,
- "pixel_decoder": build_pixel_decoder(cfg, input_shape),
- "loss_weight": cfg.MODEL.SEM_SEG_HEAD.LOSS_WEIGHT,
- "transformer_in_feature": cfg.MODEL.ONE_FORMER.TRANSFORMER_IN_FEATURE,
- "transformer_predictor": build_transformer_decoder(
- cfg,
- transformer_predictor_in_channels,
- mask_classification=True,
- ),
- }
-
- def forward(self, features, tasks, mask=None):
- return self.layers(features, tasks, mask)
-
- def layers(self, features, tasks, mask=None):
- mask_features, transformer_encoder_features, multi_scale_features, _, _ = self.pixel_decoder.forward_features(features)
-
- if self.transformer_in_feature == "multi_scale_pixel_decoder":
- predictions = self.predictor(multi_scale_features, mask_features, tasks, mask)
- else:
- if self.transformer_in_feature == "transformer_encoder":
- assert (
- transformer_encoder_features is not None
- ), "Please use the TransformerEncoderPixelDecoder."
- predictions = self.predictor(transformer_encoder_features, mask_features, mask)
- elif self.transformer_in_feature == "pixel_embedding":
- predictions = self.predictor(mask_features, mask_features, mask)
- else:
- predictions = self.predictor(features[self.transformer_in_feature], mask_features, mask)
- return predictions
diff --git a/spaces/Superlang/ImageProcessor/annotator/uniformer/mmseg/models/decode_heads/cascade_decode_head.py b/spaces/Superlang/ImageProcessor/annotator/uniformer/mmseg/models/decode_heads/cascade_decode_head.py
deleted file mode 100644
index d02122ca0e68743b1bf7a893afae96042f23838c..0000000000000000000000000000000000000000
--- a/spaces/Superlang/ImageProcessor/annotator/uniformer/mmseg/models/decode_heads/cascade_decode_head.py
+++ /dev/null
@@ -1,57 +0,0 @@
-from abc import ABCMeta, abstractmethod
-
-from .decode_head import BaseDecodeHead
-
-
-class BaseCascadeDecodeHead(BaseDecodeHead, metaclass=ABCMeta):
- """Base class for cascade decode head used in
- :class:`CascadeEncoderDecoder."""
-
- def __init__(self, *args, **kwargs):
- super(BaseCascadeDecodeHead, self).__init__(*args, **kwargs)
-
- @abstractmethod
- def forward(self, inputs, prev_output):
- """Placeholder of forward function."""
- pass
-
- def forward_train(self, inputs, prev_output, img_metas, gt_semantic_seg,
- train_cfg):
- """Forward function for training.
- Args:
- inputs (list[Tensor]): List of multi-level img features.
- prev_output (Tensor): The output of previous decode head.
- img_metas (list[dict]): List of image info dict where each dict
- has: 'img_shape', 'scale_factor', 'flip', and may also contain
- 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
- For details on the values of these keys see
- `mmseg/datasets/pipelines/formatting.py:Collect`.
- gt_semantic_seg (Tensor): Semantic segmentation masks
- used if the architecture supports semantic segmentation task.
- train_cfg (dict): The training config.
-
- Returns:
- dict[str, Tensor]: a dictionary of loss components
- """
- seg_logits = self.forward(inputs, prev_output)
- losses = self.losses(seg_logits, gt_semantic_seg)
-
- return losses
-
- def forward_test(self, inputs, prev_output, img_metas, test_cfg):
- """Forward function for testing.
-
- Args:
- inputs (list[Tensor]): List of multi-level img features.
- prev_output (Tensor): The output of previous decode head.
- img_metas (list[dict]): List of image info dict where each dict
- has: 'img_shape', 'scale_factor', 'flip', and may also contain
- 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
- For details on the values of these keys see
- `mmseg/datasets/pipelines/formatting.py:Collect`.
- test_cfg (dict): The testing config.
-
- Returns:
- Tensor: Output segmentation map.
- """
- return self.forward(inputs, prev_output)
diff --git a/spaces/TEnngal/bingo/src/pages/api/blob.ts b/spaces/TEnngal/bingo/src/pages/api/blob.ts
deleted file mode 100644
index fecd48031916b2284b8958892196e0a1ad420421..0000000000000000000000000000000000000000
--- a/spaces/TEnngal/bingo/src/pages/api/blob.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-'use server'
-
-import { NextApiRequest, NextApiResponse } from 'next'
-import { Readable } from 'node:stream'
-import { fetch } from '@/lib/isomorphic'
-
-const API_DOMAIN = 'https://www.bing.com'
-
-export default async function handler(req: NextApiRequest, res: NextApiResponse) {
- try {
- const { bcid } = req.query
-
- const { headers, body } = await fetch(`${API_DOMAIN}/images/blob?bcid=${bcid}`,
- {
- method: 'GET',
- headers: {
- "sec-ch-ua": "\"Not/A)Brand\";v=\"99\", \"Google Chrome\";v=\"115\", \"Chromium\";v=\"115\"",
- "sec-ch-ua-mobile": "?0",
- "sec-ch-ua-platform": "\"Windows\"",
- "Referrer-Policy": "origin-when-cross-origin",
- },
- },
- )
-
- res.writeHead(200, {
- 'Content-Length': headers.get('content-length')!,
- 'Content-Type': headers.get('content-type')!,
- })
- // @ts-ignore
- return Readable.fromWeb(body!).pipe(res)
- } catch (e) {
- console.log('Error', e)
- return res.json({
- result: {
- value: 'UploadFailed',
- message: `${e}`
- }
- })
- }
-}
diff --git a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/pygments/formatters/groff.py b/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/pygments/formatters/groff.py
deleted file mode 100644
index 30a528e668f8e8bcbde9b466c95a2a34bffbef8f..0000000000000000000000000000000000000000
--- a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/pygments/formatters/groff.py
+++ /dev/null
@@ -1,170 +0,0 @@
-"""
- pygments.formatters.groff
- ~~~~~~~~~~~~~~~~~~~~~~~~~
-
- Formatter for groff output.
-
- :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
- :license: BSD, see LICENSE for details.
-"""
-
-import math
-from pip._vendor.pygments.formatter import Formatter
-from pip._vendor.pygments.util import get_bool_opt, get_int_opt
-
-__all__ = ['GroffFormatter']
-
-
-class GroffFormatter(Formatter):
- """
- Format tokens with groff escapes to change their color and font style.
-
- .. versionadded:: 2.11
-
- Additional options accepted:
-
- `style`
- The style to use, can be a string or a Style subclass (default:
- ``'default'``).
-
- `monospaced`
- If set to true, monospace font will be used (default: ``true``).
-
- `linenos`
- If set to true, print the line numbers (default: ``false``).
-
- `wrap`
- Wrap lines to the specified number of characters. Disabled if set to 0
- (default: ``0``).
- """
-
- name = 'groff'
- aliases = ['groff','troff','roff']
- filenames = []
-
- def __init__(self, **options):
- Formatter.__init__(self, **options)
-
- self.monospaced = get_bool_opt(options, 'monospaced', True)
- self.linenos = get_bool_opt(options, 'linenos', False)
- self._lineno = 0
- self.wrap = get_int_opt(options, 'wrap', 0)
- self._linelen = 0
-
- self.styles = {}
- self._make_styles()
-
-
- def _make_styles(self):
- regular = '\\f[CR]' if self.monospaced else '\\f[R]'
- bold = '\\f[CB]' if self.monospaced else '\\f[B]'
- italic = '\\f[CI]' if self.monospaced else '\\f[I]'
-
- for ttype, ndef in self.style:
- start = end = ''
- if ndef['color']:
- start += '\\m[%s]' % ndef['color']
- end = '\\m[]' + end
- if ndef['bold']:
- start += bold
- end = regular + end
- if ndef['italic']:
- start += italic
- end = regular + end
- if ndef['bgcolor']:
- start += '\\M[%s]' % ndef['bgcolor']
- end = '\\M[]' + end
-
- self.styles[ttype] = start, end
-
-
- def _define_colors(self, outfile):
- colors = set()
- for _, ndef in self.style:
- if ndef['color'] is not None:
- colors.add(ndef['color'])
-
- for color in sorted(colors):
- outfile.write('.defcolor ' + color + ' rgb #' + color + '\n')
-
-
- def _write_lineno(self, outfile):
- self._lineno += 1
- outfile.write("%s% 4d " % (self._lineno != 1 and '\n' or '', self._lineno))
-
-
- def _wrap_line(self, line):
- length = len(line.rstrip('\n'))
- space = ' ' if self.linenos else ''
- newline = ''
-
- if length > self.wrap:
- for i in range(0, math.floor(length / self.wrap)):
- chunk = line[i*self.wrap:i*self.wrap+self.wrap]
- newline += (chunk + '\n' + space)
- remainder = length % self.wrap
- if remainder > 0:
- newline += line[-remainder-1:]
- self._linelen = remainder
- elif self._linelen + length > self.wrap:
- newline = ('\n' + space) + line
- self._linelen = length
- else:
- newline = line
- self._linelen += length
-
- return newline
-
-
- def _escape_chars(self, text):
- text = text.replace('\\', '\\[u005C]'). \
- replace('.', '\\[char46]'). \
- replace('\'', '\\[u0027]'). \
- replace('`', '\\[u0060]'). \
- replace('~', '\\[u007E]')
- copy = text
-
- for char in copy:
- if len(char) != len(char.encode()):
- uni = char.encode('unicode_escape') \
- .decode()[1:] \
- .replace('x', 'u00') \
- .upper()
- text = text.replace(char, '\\[u' + uni[1:] + ']')
-
- return text
-
-
- def format_unencoded(self, tokensource, outfile):
- self._define_colors(outfile)
-
- outfile.write('.nf\n\\f[CR]\n')
-
- if self.linenos:
- self._write_lineno(outfile)
-
- for ttype, value in tokensource:
- while ttype not in self.styles:
- ttype = ttype.parent
- start, end = self.styles[ttype]
-
- for line in value.splitlines(True):
- if self.wrap > 0:
- line = self._wrap_line(line)
-
- if start and end:
- text = self._escape_chars(line.rstrip('\n'))
- if text != '':
- outfile.write(''.join((start, text, end)))
- else:
- outfile.write(self._escape_chars(line.rstrip('\n')))
-
- if line.endswith('\n'):
- if self.linenos:
- self._write_lineno(outfile)
- self._linelen = 0
- else:
- outfile.write('\n')
- self._linelen = 0
-
- outfile.write('\n.fi')
diff --git a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/rich/ansi.py b/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/rich/ansi.py
deleted file mode 100644
index 66365e6536080bd9372d2a7a58b8ffa3447fec34..0000000000000000000000000000000000000000
--- a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/rich/ansi.py
+++ /dev/null
@@ -1,240 +0,0 @@
-import re
-import sys
-from contextlib import suppress
-from typing import Iterable, NamedTuple, Optional
-
-from .color import Color
-from .style import Style
-from .text import Text
-
-re_ansi = re.compile(
- r"""
-(?:\x1b\](.*?)\x1b\\)|
-(?:\x1b([(@-Z\\-_]|\[[0-?]*[ -/]*[@-~]))
-""",
- re.VERBOSE,
-)
-
-
-class _AnsiToken(NamedTuple):
- """Result of ansi tokenized string."""
-
- plain: str = ""
- sgr: Optional[str] = ""
- osc: Optional[str] = ""
-
-
-def _ansi_tokenize(ansi_text: str) -> Iterable[_AnsiToken]:
- """Tokenize a string in to plain text and ANSI codes.
-
- Args:
- ansi_text (str): A String containing ANSI codes.
-
- Yields:
- AnsiToken: A named tuple of (plain, sgr, osc)
- """
-
- position = 0
- sgr: Optional[str]
- osc: Optional[str]
- for match in re_ansi.finditer(ansi_text):
- start, end = match.span(0)
- osc, sgr = match.groups()
- if start > position:
- yield _AnsiToken(ansi_text[position:start])
- if sgr:
- if sgr == "(":
- position = end + 1
- continue
- if sgr.endswith("m"):
- yield _AnsiToken("", sgr[1:-1], osc)
- else:
- yield _AnsiToken("", sgr, osc)
- position = end
- if position < len(ansi_text):
- yield _AnsiToken(ansi_text[position:])
-
-
-SGR_STYLE_MAP = {
- 1: "bold",
- 2: "dim",
- 3: "italic",
- 4: "underline",
- 5: "blink",
- 6: "blink2",
- 7: "reverse",
- 8: "conceal",
- 9: "strike",
- 21: "underline2",
- 22: "not dim not bold",
- 23: "not italic",
- 24: "not underline",
- 25: "not blink",
- 26: "not blink2",
- 27: "not reverse",
- 28: "not conceal",
- 29: "not strike",
- 30: "color(0)",
- 31: "color(1)",
- 32: "color(2)",
- 33: "color(3)",
- 34: "color(4)",
- 35: "color(5)",
- 36: "color(6)",
- 37: "color(7)",
- 39: "default",
- 40: "on color(0)",
- 41: "on color(1)",
- 42: "on color(2)",
- 43: "on color(3)",
- 44: "on color(4)",
- 45: "on color(5)",
- 46: "on color(6)",
- 47: "on color(7)",
- 49: "on default",
- 51: "frame",
- 52: "encircle",
- 53: "overline",
- 54: "not frame not encircle",
- 55: "not overline",
- 90: "color(8)",
- 91: "color(9)",
- 92: "color(10)",
- 93: "color(11)",
- 94: "color(12)",
- 95: "color(13)",
- 96: "color(14)",
- 97: "color(15)",
- 100: "on color(8)",
- 101: "on color(9)",
- 102: "on color(10)",
- 103: "on color(11)",
- 104: "on color(12)",
- 105: "on color(13)",
- 106: "on color(14)",
- 107: "on color(15)",
-}
-
-
-class AnsiDecoder:
- """Translate ANSI code in to styled Text."""
-
- def __init__(self) -> None:
- self.style = Style.null()
-
- def decode(self, terminal_text: str) -> Iterable[Text]:
- """Decode ANSI codes in an iterable of lines.
-
- Args:
- lines (Iterable[str]): An iterable of lines of terminal output.
-
- Yields:
- Text: Marked up Text.
- """
- for line in terminal_text.splitlines():
- yield self.decode_line(line)
-
- def decode_line(self, line: str) -> Text:
- """Decode a line containing ansi codes.
-
- Args:
- line (str): A line of terminal output.
-
- Returns:
- Text: A Text instance marked up according to ansi codes.
- """
- from_ansi = Color.from_ansi
- from_rgb = Color.from_rgb
- _Style = Style
- text = Text()
- append = text.append
- line = line.rsplit("\r", 1)[-1]
- for plain_text, sgr, osc in _ansi_tokenize(line):
- if plain_text:
- append(plain_text, self.style or None)
- elif osc is not None:
- if osc.startswith("8;"):
- _params, semicolon, link = osc[2:].partition(";")
- if semicolon:
- self.style = self.style.update_link(link or None)
- elif sgr is not None:
- # Translate in to semi-colon separated codes
- # Ignore invalid codes, because we want to be lenient
- codes = [
- min(255, int(_code) if _code else 0)
- for _code in sgr.split(";")
- if _code.isdigit() or _code == ""
- ]
- iter_codes = iter(codes)
- for code in iter_codes:
- if code == 0:
- # reset
- self.style = _Style.null()
- elif code in SGR_STYLE_MAP:
- # styles
- self.style += _Style.parse(SGR_STYLE_MAP[code])
- elif code == 38:
- # Foreground
- with suppress(StopIteration):
- color_type = next(iter_codes)
- if color_type == 5:
- self.style += _Style.from_color(
- from_ansi(next(iter_codes))
- )
- elif color_type == 2:
- self.style += _Style.from_color(
- from_rgb(
- next(iter_codes),
- next(iter_codes),
- next(iter_codes),
- )
- )
- elif code == 48:
- # Background
- with suppress(StopIteration):
- color_type = next(iter_codes)
- if color_type == 5:
- self.style += _Style.from_color(
- None, from_ansi(next(iter_codes))
- )
- elif color_type == 2:
- self.style += _Style.from_color(
- None,
- from_rgb(
- next(iter_codes),
- next(iter_codes),
- next(iter_codes),
- ),
- )
-
- return text
-
-
-if sys.platform != "win32" and __name__ == "__main__": # pragma: no cover
- import io
- import os
- import pty
- import sys
-
- decoder = AnsiDecoder()
-
- stdout = io.BytesIO()
-
- def read(fd: int) -> bytes:
- data = os.read(fd, 1024)
- stdout.write(data)
- return data
-
- pty.spawn(sys.argv[1:], read)
-
- from .console import Console
-
- console = Console(record=True)
-
- stdout_result = stdout.getvalue().decode("utf-8")
- print(stdout_result)
-
- for line in decoder.decode(stdout_result):
- console.print(line)
-
- console.save_html("stdout.html")
diff --git a/spaces/TechnoByte/soft-improved/theme_dropdown.py b/spaces/TechnoByte/soft-improved/theme_dropdown.py
deleted file mode 100644
index 6235388fd00549553df44028f3ccf03e946994ea..0000000000000000000000000000000000000000
--- a/spaces/TechnoByte/soft-improved/theme_dropdown.py
+++ /dev/null
@@ -1,57 +0,0 @@
-import os
-import pathlib
-
-from gradio.themes.utils import ThemeAsset
-
-
-def create_theme_dropdown():
- import gradio as gr
-
- asset_path = pathlib.Path(__file__).parent / "themes"
- themes = []
- for theme_asset in os.listdir(str(asset_path)):
- themes.append(
- (ThemeAsset(theme_asset), gr.Theme.load(str(asset_path / theme_asset)))
- )
-
- def make_else_if(theme_asset):
- return f"""
- else if (theme == '{str(theme_asset[0].version)}') {{
- var theme_css = `{theme_asset[1]._get_theme_css()}`
- }}"""
-
- head, tail = themes[0], themes[1:]
- if_statement = f"""
- if (theme == "{str(head[0].version)}") {{
- var theme_css = `{head[1]._get_theme_css()}`
- }} {" ".join(make_else_if(t) for t in tail)}
- """
-
- latest_to_oldest = sorted([t[0] for t in themes], key=lambda asset: asset.version)[
- ::-1
- ]
- latest_to_oldest = [str(t.version) for t in latest_to_oldest]
-
- component = gr.Dropdown(
- choices=latest_to_oldest,
- value=latest_to_oldest[0],
- render=False,
- label="Select Version",
- ).style(container=False)
-
- return (
- component,
- f"""
- (theme) => {{
- if (!document.querySelector('.theme-css')) {{
- var theme_elem = document.createElement('style');
- theme_elem.classList.add('theme-css');
- document.head.appendChild(theme_elem);
- }} else {{
- var theme_elem = document.querySelector('.theme-css');
- }}
- {if_statement}
- theme_elem.innerHTML = theme_css;
- }}
- """,
- )
diff --git a/spaces/TencentARC/Caption-Anything/README.md b/spaces/TencentARC/Caption-Anything/README.md
deleted file mode 100644
index 5cf7a4f5679a7d7037957243442d7aba615993f9..0000000000000000000000000000000000000000
--- a/spaces/TencentARC/Caption-Anything/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: Caption Anything
-emoji: 📚
-colorFrom: green
-colorTo: green
-sdk: gradio
-sdk_version: 3.26.0
-python_version: 3.8.9
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/ThomasSimonini/Conversation-in-a-Tavern/app.py b/spaces/ThomasSimonini/Conversation-in-a-Tavern/app.py
deleted file mode 100644
index 401574fd656a308a56018a1f9fc3c4ad366cb5e0..0000000000000000000000000000000000000000
--- a/spaces/ThomasSimonini/Conversation-in-a-Tavern/app.py
+++ /dev/null
@@ -1,106 +0,0 @@
-import gradio as gr
-from gradio.inputs import Textbox, Slider
-
-import requests
-
-# Template
-title = "A conversation with some NPC in a Tavern 🍻"
-description = ""
-article = """
- If you liked don't forget to 💖 the project 🥰
- Parameters:
-
- - message: what you want to say to the NPC.
- - npc_name: name of the NPC.
- - npc_prompt: prompt of the NPC, we can modify it to see if results are better.
- - top_p: control how deterministic the model is in generating a response.
- - temperature: (sampling temperature) higher values means the model will take more risks.
- - max_new_tokens: Max number of tokens in generation.
-
-
"""
-theme="huggingface"
-
-
-# Builds the prompt from what previously happened
-def build_prompt(conversation, context, interlocutor_names):
- prompt = context + "\n"
- for player_msg, npc_msg in conversation:
- line = "\n- " + interlocutor_names[0] + ":" + player_msg
- prompt += line
- line = "\n- " + interlocutor_names[1] + ":" + npc_msg
- prompt += line
- prompt += ""
- return prompt
-
-# Recognize what the model said, if it used the correct format
-def clean_chat_output(txt, prompt, interlocutor_names):
- delimiter = "\n- "+interlocutor_names[0]
- output = txt.replace(prompt, '')
- output = output[:output.find(delimiter)]
- return output
-
-# GPT-J-6B API
-API_URL = "https://api-inference.huggingface.co/models/EleutherAI/gpt-j-6B"
-def query(payload):
- response = requests.post(API_URL, json=payload)
- return response.json()
-
-def chat(message, npc_name, initial_prompt, top_p, temperature, max_new_tokens, history=[]):
- interlocutor_names = ["Player", npc_name]
-
- print("message", message)
- print("npc_name", npc_name)
- print("initial_prompt", initial_prompt)
- print("top_p", top_p)
- print("temperature", temperature)
- print("max_new_tokens", max_new_tokens)
- print("history", history)
- response = "Test"
- history.append((message, ""))
- conversation = history
-
- # Build the prompt
- prompt = build_prompt(conversation, initial_prompt, interlocutor_names)
-
- # Build JSON
- json_req = {"inputs": prompt,
- "parameters":
- {
- "top_p": top_p,
- "temperature": temperature,
- "max_new_tokens": max_new_tokens,
- "return_full_text": False
- }}
-
- # Get the output
- output = query(json_req)
- output = output[0]['generated_text']
- print("output", output)
-
- answer = clean_chat_output(output, prompt, interlocutor_names)
- response = answer
- print("response", answer)
- history[-1] = (message, response)
- return history, history
-
-
-#io = gr.Interface.load("huggingface/EleutherAI/gpt-j-6B")
-
-iface = gr.Interface(fn=chat,
-inputs=[Textbox(label="message", placeholder="Hello!"),
- Textbox(label="npc_name", placeholder="Antoine"),
- Textbox(label="initial_prompt", placeholder="The following is a conversation with Antoine, a guard for Northfall that's drinking in the Tavern."),
- Slider(minimum=0.5, maximum=1, step=0.05, default=0.9, label="top_p"),
- Slider(minimum=0.5, maximum=1.5, step=0.1, default=1.1, label="temperature"),
- Slider(minimum=20, maximum=250, step=10, default=50, label="max_new_tokens"),
- "state"],
- outputs=["chatbot","state"],
- #examples = [["Hello!", "", , 0.9, 1.1, 50, iface.state]],
- allow_screenshot=True,
- allow_flagging=True,
- title=title,
- article=article,
- theme=theme)
-
-if __name__ == "__main__":
- iface.launch()
\ No newline at end of file
diff --git a/spaces/TushDeMort/yolo/utils/torch_utils.py b/spaces/TushDeMort/yolo/utils/torch_utils.py
deleted file mode 100644
index 1e631b555508457a4944c11a479176463719c0e8..0000000000000000000000000000000000000000
--- a/spaces/TushDeMort/yolo/utils/torch_utils.py
+++ /dev/null
@@ -1,374 +0,0 @@
-# YOLOR PyTorch utils
-
-import datetime
-import logging
-import math
-import os
-import platform
-import subprocess
-import time
-from contextlib import contextmanager
-from copy import deepcopy
-from pathlib import Path
-
-import torch
-import torch.backends.cudnn as cudnn
-import torch.nn as nn
-import torch.nn.functional as F
-import torchvision
-
-try:
- import thop # for FLOPS computation
-except ImportError:
- thop = None
-logger = logging.getLogger(__name__)
-
-
-@contextmanager
-def torch_distributed_zero_first(local_rank: int):
- """
- Decorator to make all processes in distributed training wait for each local_master to do something.
- """
- if local_rank not in [-1, 0]:
- torch.distributed.barrier()
- yield
- if local_rank == 0:
- torch.distributed.barrier()
-
-
-def init_torch_seeds(seed=0):
- # Speed-reproducibility tradeoff https://pytorch.org/docs/stable/notes/randomness.html
- torch.manual_seed(seed)
- if seed == 0: # slower, more reproducible
- cudnn.benchmark, cudnn.deterministic = False, True
- else: # faster, less reproducible
- cudnn.benchmark, cudnn.deterministic = True, False
-
-
-def date_modified(path=__file__):
- # return human-readable file modification date, i.e. '2021-3-26'
- t = datetime.datetime.fromtimestamp(Path(path).stat().st_mtime)
- return f'{t.year}-{t.month}-{t.day}'
-
-
-def git_describe(path=Path(__file__).parent): # path must be a directory
- # return human-readable git description, i.e. v5.0-5-g3e25f1e https://git-scm.com/docs/git-describe
- s = f'git -C {path} describe --tags --long --always'
- try:
- return subprocess.check_output(s, shell=True, stderr=subprocess.STDOUT).decode()[:-1]
- except subprocess.CalledProcessError as e:
- return '' # not a git repository
-
-
-def select_device(device='', batch_size=None):
- # device = 'cpu' or '0' or '0,1,2,3'
- s = f'YOLOR 🚀 {git_describe() or date_modified()} torch {torch.__version__} ' # string
- cpu = device.lower() == 'cpu'
- if cpu:
- os.environ['CUDA_VISIBLE_DEVICES'] = '-1' # force torch.cuda.is_available() = False
- elif device: # non-cpu device requested
- os.environ['CUDA_VISIBLE_DEVICES'] = device # set environment variable
- assert torch.cuda.is_available(), f'CUDA unavailable, invalid device {device} requested' # check availability
-
- cuda = not cpu and torch.cuda.is_available()
- if cuda:
- n = torch.cuda.device_count()
- if n > 1 and batch_size: # check that batch_size is compatible with device_count
- assert batch_size % n == 0, f'batch-size {batch_size} not multiple of GPU count {n}'
- space = ' ' * len(s)
- for i, d in enumerate(device.split(',') if device else range(n)):
- p = torch.cuda.get_device_properties(i)
- s += f"{'' if i == 0 else space}CUDA:{d} ({p.name}, {p.total_memory / 1024 ** 2}MB)\n" # bytes to MB
- else:
- s += 'CPU\n'
-
- logger.info(s.encode().decode('ascii', 'ignore') if platform.system() == 'Windows' else s) # emoji-safe
- return torch.device('cuda:0' if cuda else 'cpu')
-
-
-def time_synchronized():
- # pytorch-accurate time
- if torch.cuda.is_available():
- torch.cuda.synchronize()
- return time.time()
-
-
-def profile(x, ops, n=100, device=None):
- # profile a pytorch module or list of modules. Example usage:
- # x = torch.randn(16, 3, 640, 640) # input
- # m1 = lambda x: x * torch.sigmoid(x)
- # m2 = nn.SiLU()
- # profile(x, [m1, m2], n=100) # profile speed over 100 iterations
-
- device = device or torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
- x = x.to(device)
- x.requires_grad = True
- print(torch.__version__, device.type, torch.cuda.get_device_properties(0) if device.type == 'cuda' else '')
- print(f"\n{'Params':>12s}{'GFLOPS':>12s}{'forward (ms)':>16s}{'backward (ms)':>16s}{'input':>24s}{'output':>24s}")
- for m in ops if isinstance(ops, list) else [ops]:
- m = m.to(device) if hasattr(m, 'to') else m # device
- m = m.half() if hasattr(m, 'half') and isinstance(x, torch.Tensor) and x.dtype is torch.float16 else m # type
- dtf, dtb, t = 0., 0., [0., 0., 0.] # dt forward, backward
- try:
- flops = thop.profile(m, inputs=(x,), verbose=False)[0] / 1E9 * 2 # GFLOPS
- except:
- flops = 0
-
- for _ in range(n):
- t[0] = time_synchronized()
- y = m(x)
- t[1] = time_synchronized()
- try:
- _ = y.sum().backward()
- t[2] = time_synchronized()
- except: # no backward method
- t[2] = float('nan')
- dtf += (t[1] - t[0]) * 1000 / n # ms per op forward
- dtb += (t[2] - t[1]) * 1000 / n # ms per op backward
-
- s_in = tuple(x.shape) if isinstance(x, torch.Tensor) else 'list'
- s_out = tuple(y.shape) if isinstance(y, torch.Tensor) else 'list'
- p = sum(list(x.numel() for x in m.parameters())) if isinstance(m, nn.Module) else 0 # parameters
- print(f'{p:12}{flops:12.4g}{dtf:16.4g}{dtb:16.4g}{str(s_in):>24s}{str(s_out):>24s}')
-
-
-def is_parallel(model):
- return type(model) in (nn.parallel.DataParallel, nn.parallel.DistributedDataParallel)
-
-
-def intersect_dicts(da, db, exclude=()):
- # Dictionary intersection of matching keys and shapes, omitting 'exclude' keys, using da values
- return {k: v for k, v in da.items() if k in db and not any(x in k for x in exclude) and v.shape == db[k].shape}
-
-
-def initialize_weights(model):
- for m in model.modules():
- t = type(m)
- if t is nn.Conv2d:
- pass # nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
- elif t is nn.BatchNorm2d:
- m.eps = 1e-3
- m.momentum = 0.03
- elif t in [nn.Hardswish, nn.LeakyReLU, nn.ReLU, nn.ReLU6]:
- m.inplace = True
-
-
-def find_modules(model, mclass=nn.Conv2d):
- # Finds layer indices matching module class 'mclass'
- return [i for i, m in enumerate(model.module_list) if isinstance(m, mclass)]
-
-
-def sparsity(model):
- # Return global model sparsity
- a, b = 0., 0.
- for p in model.parameters():
- a += p.numel()
- b += (p == 0).sum()
- return b / a
-
-
-def prune(model, amount=0.3):
- # Prune model to requested global sparsity
- import torch.nn.utils.prune as prune
- print('Pruning model... ', end='')
- for name, m in model.named_modules():
- if isinstance(m, nn.Conv2d):
- prune.l1_unstructured(m, name='weight', amount=amount) # prune
- prune.remove(m, 'weight') # make permanent
- print(' %.3g global sparsity' % sparsity(model))
-
-
-def fuse_conv_and_bn(conv, bn):
- # Fuse convolution and batchnorm layers https://tehnokv.com/posts/fusing-batchnorm-and-conv/
- fusedconv = nn.Conv2d(conv.in_channels,
- conv.out_channels,
- kernel_size=conv.kernel_size,
- stride=conv.stride,
- padding=conv.padding,
- groups=conv.groups,
- bias=True).requires_grad_(False).to(conv.weight.device)
-
- # prepare filters
- w_conv = conv.weight.clone().view(conv.out_channels, -1)
- w_bn = torch.diag(bn.weight.div(torch.sqrt(bn.eps + bn.running_var)))
- fusedconv.weight.copy_(torch.mm(w_bn, w_conv).view(fusedconv.weight.shape))
-
- # prepare spatial bias
- b_conv = torch.zeros(conv.weight.size(0), device=conv.weight.device) if conv.bias is None else conv.bias
- b_bn = bn.bias - bn.weight.mul(bn.running_mean).div(torch.sqrt(bn.running_var + bn.eps))
- fusedconv.bias.copy_(torch.mm(w_bn, b_conv.reshape(-1, 1)).reshape(-1) + b_bn)
-
- return fusedconv
-
-
-def model_info(model, verbose=False, img_size=640):
- # Model information. img_size may be int or list, i.e. img_size=640 or img_size=[640, 320]
- n_p = sum(x.numel() for x in model.parameters()) # number parameters
- n_g = sum(x.numel() for x in model.parameters() if x.requires_grad) # number gradients
- if verbose:
- print('%5s %40s %9s %12s %20s %10s %10s' % ('layer', 'name', 'gradient', 'parameters', 'shape', 'mu', 'sigma'))
- for i, (name, p) in enumerate(model.named_parameters()):
- name = name.replace('module_list.', '')
- print('%5g %40s %9s %12g %20s %10.3g %10.3g' %
- (i, name, p.requires_grad, p.numel(), list(p.shape), p.mean(), p.std()))
-
- try: # FLOPS
- from thop import profile
- stride = max(int(model.stride.max()), 32) if hasattr(model, 'stride') else 32
- img = torch.zeros((1, model.yaml.get('ch', 3), stride, stride), device=next(model.parameters()).device) # input
- flops = profile(deepcopy(model), inputs=(img,), verbose=False)[0] / 1E9 * 2 # stride GFLOPS
- img_size = img_size if isinstance(img_size, list) else [img_size, img_size] # expand if int/float
- fs = ', %.1f GFLOPS' % (flops * img_size[0] / stride * img_size[1] / stride) # 640x640 GFLOPS
- except (ImportError, Exception):
- fs = ''
-
- logger.info(f"Model Summary: {len(list(model.modules()))} layers, {n_p} parameters, {n_g} gradients{fs}")
-
-
-def load_classifier(name='resnet101', n=2):
- # Loads a pretrained model reshaped to n-class output
- model = torchvision.models.__dict__[name](pretrained=True)
-
- # ResNet model properties
- # input_size = [3, 224, 224]
- # input_space = 'RGB'
- # input_range = [0, 1]
- # mean = [0.485, 0.456, 0.406]
- # std = [0.229, 0.224, 0.225]
-
- # Reshape output to n classes
- filters = model.fc.weight.shape[1]
- model.fc.bias = nn.Parameter(torch.zeros(n), requires_grad=True)
- model.fc.weight = nn.Parameter(torch.zeros(n, filters), requires_grad=True)
- model.fc.out_features = n
- return model
-
-
-def scale_img(img, ratio=1.0, same_shape=False, gs=32): # img(16,3,256,416)
- # scales img(bs,3,y,x) by ratio constrained to gs-multiple
- if ratio == 1.0:
- return img
- else:
- h, w = img.shape[2:]
- s = (int(h * ratio), int(w * ratio)) # new size
- img = F.interpolate(img, size=s, mode='bilinear', align_corners=False) # resize
- if not same_shape: # pad/crop img
- h, w = [math.ceil(x * ratio / gs) * gs for x in (h, w)]
- return F.pad(img, [0, w - s[1], 0, h - s[0]], value=0.447) # value = imagenet mean
-
-
-def copy_attr(a, b, include=(), exclude=()):
- # Copy attributes from b to a, options to only include [...] and to exclude [...]
- for k, v in b.__dict__.items():
- if (len(include) and k not in include) or k.startswith('_') or k in exclude:
- continue
- else:
- setattr(a, k, v)
-
-
-class ModelEMA:
- """ Model Exponential Moving Average from https://github.com/rwightman/pytorch-image-models
- Keep a moving average of everything in the model state_dict (parameters and buffers).
- This is intended to allow functionality like
- https://www.tensorflow.org/api_docs/python/tf/train/ExponentialMovingAverage
- A smoothed version of the weights is necessary for some training schemes to perform well.
- This class is sensitive where it is initialized in the sequence of model init,
- GPU assignment and distributed training wrappers.
- """
-
- def __init__(self, model, decay=0.9999, updates=0):
- # Create EMA
- self.ema = deepcopy(model.module if is_parallel(model) else model).eval() # FP32 EMA
- # if next(model.parameters()).device.type != 'cpu':
- # self.ema.half() # FP16 EMA
- self.updates = updates # number of EMA updates
- self.decay = lambda x: decay * (1 - math.exp(-x / 2000)) # decay exponential ramp (to help early epochs)
- for p in self.ema.parameters():
- p.requires_grad_(False)
-
- def update(self, model):
- # Update EMA parameters
- with torch.no_grad():
- self.updates += 1
- d = self.decay(self.updates)
-
- msd = model.module.state_dict() if is_parallel(model) else model.state_dict() # model state_dict
- for k, v in self.ema.state_dict().items():
- if v.dtype.is_floating_point:
- v *= d
- v += (1. - d) * msd[k].detach()
-
- def update_attr(self, model, include=(), exclude=('process_group', 'reducer')):
- # Update EMA attributes
- copy_attr(self.ema, model, include, exclude)
-
-
-class BatchNormXd(torch.nn.modules.batchnorm._BatchNorm):
- def _check_input_dim(self, input):
- # The only difference between BatchNorm1d, BatchNorm2d, BatchNorm3d, etc
- # is this method that is overwritten by the sub-class
- # This original goal of this method was for tensor sanity checks
- # If you're ok bypassing those sanity checks (eg. if you trust your inference
- # to provide the right dimensional inputs), then you can just use this method
- # for easy conversion from SyncBatchNorm
- # (unfortunately, SyncBatchNorm does not store the original class - if it did
- # we could return the one that was originally created)
- return
-
-def revert_sync_batchnorm(module):
- # this is very similar to the function that it is trying to revert:
- # https://github.com/pytorch/pytorch/blob/c8b3686a3e4ba63dc59e5dcfe5db3430df256833/torch/nn/modules/batchnorm.py#L679
- module_output = module
- if isinstance(module, torch.nn.modules.batchnorm.SyncBatchNorm):
- new_cls = BatchNormXd
- module_output = BatchNormXd(module.num_features,
- module.eps, module.momentum,
- module.affine,
- module.track_running_stats)
- if module.affine:
- with torch.no_grad():
- module_output.weight = module.weight
- module_output.bias = module.bias
- module_output.running_mean = module.running_mean
- module_output.running_var = module.running_var
- module_output.num_batches_tracked = module.num_batches_tracked
- if hasattr(module, "qconfig"):
- module_output.qconfig = module.qconfig
- for name, child in module.named_children():
- module_output.add_module(name, revert_sync_batchnorm(child))
- del module
- return module_output
-
-
-class TracedModel(nn.Module):
-
- def __init__(self, model=None, device=None, img_size=(640,640)):
- super(TracedModel, self).__init__()
-
- print(" Convert model to Traced-model... ")
- self.stride = model.stride
- self.names = model.names
- self.model = model
-
- self.model = revert_sync_batchnorm(self.model)
- self.model.to('cpu')
- self.model.eval()
-
- self.detect_layer = self.model.model[-1]
- self.model.traced = True
-
- rand_example = torch.rand(1, 3, img_size, img_size)
-
- traced_script_module = torch.jit.trace(self.model, rand_example, strict=False)
- #traced_script_module = torch.jit.script(self.model)
- traced_script_module.save("traced_model.pt")
- print(" traced_script_module saved! ")
- self.model = traced_script_module
- self.model.to(device)
- self.detect_layer.to(device)
- print(" model is traced! \n")
-
- def forward(self, x, augment=False, profile=False):
- out = self.model(x)
- out = self.detect_layer(out)
- return out
\ No newline at end of file
diff --git a/spaces/UzNutq/README/README.md b/spaces/UzNutq/README/README.md
deleted file mode 100644
index 67bde24474b2ddeb20470f34662efd907766da3e..0000000000000000000000000000000000000000
--- a/spaces/UzNutq/README/README.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: README
-emoji: 💻
-colorFrom: yellow
-colorTo: blue
-sdk: static
-pinned: true
----
-
-Edit this `README.md` markdown file to author your organization card 🔥
diff --git a/spaces/Venafi/Vikram-Explorer/README.md b/spaces/Venafi/Vikram-Explorer/README.md
deleted file mode 100644
index e0d49ac46a1c41b31bcb504432018f8144e4c561..0000000000000000000000000000000000000000
--- a/spaces/Venafi/Vikram-Explorer/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Vikram Explorer Project
-emoji: 🚀
-colorFrom: gray
-colorTo: gray
-sdk: gradio
-sdk_version: 3.42.0
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/VickyKira/NASAGPT/g4f/Provider/Provider.py b/spaces/VickyKira/NASAGPT/g4f/Provider/Provider.py
deleted file mode 100644
index d24df76b6a6ccfc9b244f13a51bfc124b398a271..0000000000000000000000000000000000000000
--- a/spaces/VickyKira/NASAGPT/g4f/Provider/Provider.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import os
-from ..typing import sha256, Dict, get_type_hints
-
-url = None
-model = None
-supports_stream = False
-needs_auth = False
-
-
-def _create_completion(model: str, messages: list, stream: bool, **kwargs):
- return
-
-
-params = f'g4f.Providers.{os.path.basename(__file__)[:-3]} supports: ' + \
- '(%s)' % ', '.join(
- [f"{name}: {get_type_hints(_create_completion)[name].__name__}" for name in _create_completion.__code__.co_varnames[:_create_completion.__code__.co_argcount]])
diff --git a/spaces/VideoCrafter/VideoCrafter/lvdm/modules/attention.py b/spaces/VideoCrafter/VideoCrafter/lvdm/modules/attention.py
deleted file mode 100644
index 3d3140c216b85a14a33d9b1fa09eb6d19465f741..0000000000000000000000000000000000000000
--- a/spaces/VideoCrafter/VideoCrafter/lvdm/modules/attention.py
+++ /dev/null
@@ -1,475 +0,0 @@
-from functools import partial
-import torch
-from torch import nn, einsum
-import torch.nn.functional as F
-from einops import rearrange, repeat
-try:
- import xformers
- import xformers.ops
- XFORMERS_IS_AVAILBLE = True
-except:
- XFORMERS_IS_AVAILBLE = False
-from lvdm.common import (
- checkpoint,
- exists,
- default,
-)
-from lvdm.basics import (
- zero_module,
-)
-
-class RelativePosition(nn.Module):
- """ https://github.com/evelinehong/Transformer_Relative_Position_PyTorch/blob/master/relative_position.py """
-
- def __init__(self, num_units, max_relative_position):
- super().__init__()
- self.num_units = num_units
- self.max_relative_position = max_relative_position
- self.embeddings_table = nn.Parameter(torch.Tensor(max_relative_position * 2 + 1, num_units))
- nn.init.xavier_uniform_(self.embeddings_table)
-
- def forward(self, length_q, length_k):
- device = self.embeddings_table.device
- range_vec_q = torch.arange(length_q, device=device)
- range_vec_k = torch.arange(length_k, device=device)
- distance_mat = range_vec_k[None, :] - range_vec_q[:, None]
- distance_mat_clipped = torch.clamp(distance_mat, -self.max_relative_position, self.max_relative_position)
- final_mat = distance_mat_clipped + self.max_relative_position
- final_mat = final_mat.long()
- embeddings = self.embeddings_table[final_mat]
- return embeddings
-
-
-class CrossAttention(nn.Module):
-
- def __init__(self, query_dim, context_dim=None, heads=8, dim_head=64, dropout=0.,
- relative_position=False, temporal_length=None, img_cross_attention=False):
- super().__init__()
- inner_dim = dim_head * heads
- context_dim = default(context_dim, query_dim)
-
- self.scale = dim_head**-0.5
- self.heads = heads
- self.dim_head = dim_head
- self.to_q = nn.Linear(query_dim, inner_dim, bias=False)
- self.to_k = nn.Linear(context_dim, inner_dim, bias=False)
- self.to_v = nn.Linear(context_dim, inner_dim, bias=False)
- self.to_out = nn.Sequential(nn.Linear(inner_dim, query_dim), nn.Dropout(dropout))
-
- self.image_cross_attention_scale = 1.0
- self.text_context_len = 77
- self.img_cross_attention = img_cross_attention
- if self.img_cross_attention:
- self.to_k_ip = nn.Linear(context_dim, inner_dim, bias=False)
- self.to_v_ip = nn.Linear(context_dim, inner_dim, bias=False)
-
- self.relative_position = relative_position
- if self.relative_position:
- assert(temporal_length is not None)
- self.relative_position_k = RelativePosition(num_units=dim_head, max_relative_position=temporal_length)
- self.relative_position_v = RelativePosition(num_units=dim_head, max_relative_position=temporal_length)
- else:
- ## only used for spatial attention, while NOT for temporal attention
- if XFORMERS_IS_AVAILBLE and temporal_length is None:
- self.forward = self.efficient_forward
-
- def forward(self, x, context=None, mask=None):
- h = self.heads
-
- q = self.to_q(x)
- context = default(context, x)
- ## considering image token additionally
- if context is not None and self.img_cross_attention:
- context, context_img = context[:,:self.text_context_len,:], context[:,self.text_context_len:,:]
- k = self.to_k(context)
- v = self.to_v(context)
- k_ip = self.to_k_ip(context_img)
- v_ip = self.to_v_ip(context_img)
- else:
- k = self.to_k(context)
- v = self.to_v(context)
-
- q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h), (q, k, v))
- sim = torch.einsum('b i d, b j d -> b i j', q, k) * self.scale
- if self.relative_position:
- len_q, len_k, len_v = q.shape[1], k.shape[1], v.shape[1]
- k2 = self.relative_position_k(len_q, len_k)
- sim2 = einsum('b t d, t s d -> b t s', q, k2) * self.scale # TODO check
- sim += sim2
- del k
-
- if exists(mask):
- ## feasible for causal attention mask only
- max_neg_value = -torch.finfo(sim.dtype).max
- mask = repeat(mask, 'b i j -> (b h) i j', h=h)
- sim.masked_fill_(~(mask>0.5), max_neg_value)
-
- # attention, what we cannot get enough of
- sim = sim.softmax(dim=-1)
- out = torch.einsum('b i j, b j d -> b i d', sim, v)
- if self.relative_position:
- v2 = self.relative_position_v(len_q, len_v)
- out2 = einsum('b t s, t s d -> b t d', sim, v2) # TODO check
- out += out2
- out = rearrange(out, '(b h) n d -> b n (h d)', h=h)
-
- ## considering image token additionally
- if context is not None and self.img_cross_attention:
- k_ip, v_ip = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h), (k_ip, v_ip))
- sim_ip = torch.einsum('b i d, b j d -> b i j', q, k_ip) * self.scale
- del k_ip
- sim_ip = sim_ip.softmax(dim=-1)
- out_ip = torch.einsum('b i j, b j d -> b i d', sim_ip, v_ip)
- out_ip = rearrange(out, '(b h) n d -> b n (h d)', h=h)
- out = out + self.image_cross_attention_scale * out_ip
- del q
-
- return self.to_out(out)
-
- def efficient_forward(self, x, context=None, mask=None):
- q = self.to_q(x)
- context = default(context, x)
-
- ## considering image token additionally
- if context is not None and self.img_cross_attention:
- context, context_img = context[:,:self.text_context_len,:], context[:,self.text_context_len:,:]
- k = self.to_k(context)
- v = self.to_v(context)
- k_ip = self.to_k_ip(context_img)
- v_ip = self.to_v_ip(context_img)
- else:
- k = self.to_k(context)
- v = self.to_v(context)
-
- b, _, _ = q.shape
- q, k, v = map(
- lambda t: t.unsqueeze(3)
- .reshape(b, t.shape[1], self.heads, self.dim_head)
- .permute(0, 2, 1, 3)
- .reshape(b * self.heads, t.shape[1], self.dim_head)
- .contiguous(),
- (q, k, v),
- )
- # actually compute the attention, what we cannot get enough of
- out = xformers.ops.memory_efficient_attention(q, k, v, attn_bias=None, op=None)
-
- ## considering image token additionally
- if context is not None and self.img_cross_attention:
- k_ip, v_ip = map(
- lambda t: t.unsqueeze(3)
- .reshape(b, t.shape[1], self.heads, self.dim_head)
- .permute(0, 2, 1, 3)
- .reshape(b * self.heads, t.shape[1], self.dim_head)
- .contiguous(),
- (k_ip, v_ip),
- )
- out_ip = xformers.ops.memory_efficient_attention(q, k_ip, v_ip, attn_bias=None, op=None)
- out_ip = (
- out_ip.unsqueeze(0)
- .reshape(b, self.heads, out.shape[1], self.dim_head)
- .permute(0, 2, 1, 3)
- .reshape(b, out.shape[1], self.heads * self.dim_head)
- )
-
- if exists(mask):
- raise NotImplementedError
- out = (
- out.unsqueeze(0)
- .reshape(b, self.heads, out.shape[1], self.dim_head)
- .permute(0, 2, 1, 3)
- .reshape(b, out.shape[1], self.heads * self.dim_head)
- )
- if context is not None and self.img_cross_attention:
- out = out + self.image_cross_attention_scale * out_ip
- return self.to_out(out)
-
-
-class BasicTransformerBlock(nn.Module):
-
- def __init__(self, dim, n_heads, d_head, dropout=0., context_dim=None, gated_ff=True, checkpoint=True,
- disable_self_attn=False, attention_cls=None, img_cross_attention=False):
- super().__init__()
- attn_cls = CrossAttention if attention_cls is None else attention_cls
- self.disable_self_attn = disable_self_attn
- self.attn1 = attn_cls(query_dim=dim, heads=n_heads, dim_head=d_head, dropout=dropout,
- context_dim=context_dim if self.disable_self_attn else None)
- self.ff = FeedForward(dim, dropout=dropout, glu=gated_ff)
- self.attn2 = attn_cls(query_dim=dim, context_dim=context_dim, heads=n_heads, dim_head=d_head, dropout=dropout,
- img_cross_attention=img_cross_attention)
- self.norm1 = nn.LayerNorm(dim)
- self.norm2 = nn.LayerNorm(dim)
- self.norm3 = nn.LayerNorm(dim)
- self.checkpoint = checkpoint
-
- def forward(self, x, context=None, mask=None):
- ## implementation tricks: because checkpointing doesn't support non-tensor (e.g. None or scalar) arguments
- input_tuple = (x,) ## should not be (x), otherwise *input_tuple will decouple x into multiple arguments
- if context is not None:
- input_tuple = (x, context)
- if mask is not None:
- forward_mask = partial(self._forward, mask=mask)
- return checkpoint(forward_mask, (x,), self.parameters(), self.checkpoint)
- if context is not None and mask is not None:
- input_tuple = (x, context, mask)
- return checkpoint(self._forward, input_tuple, self.parameters(), self.checkpoint)
-
- def _forward(self, x, context=None, mask=None):
- x = self.attn1(self.norm1(x), context=context if self.disable_self_attn else None, mask=mask) + x
- x = self.attn2(self.norm2(x), context=context, mask=mask) + x
- x = self.ff(self.norm3(x)) + x
- return x
-
-
-class SpatialTransformer(nn.Module):
- """
- Transformer block for image-like data in spatial axis.
- First, project the input (aka embedding)
- and reshape to b, t, d.
- Then apply standard transformer action.
- Finally, reshape to image
- NEW: use_linear for more efficiency instead of the 1x1 convs
- """
-
- def __init__(self, in_channels, n_heads, d_head, depth=1, dropout=0., context_dim=None,
- use_checkpoint=True, disable_self_attn=False, use_linear=False, img_cross_attention=False):
- super().__init__()
- self.in_channels = in_channels
- inner_dim = n_heads * d_head
- self.norm = torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
- if not use_linear:
- self.proj_in = nn.Conv2d(in_channels, inner_dim, kernel_size=1, stride=1, padding=0)
- else:
- self.proj_in = nn.Linear(in_channels, inner_dim)
-
- self.transformer_blocks = nn.ModuleList([
- BasicTransformerBlock(
- inner_dim,
- n_heads,
- d_head,
- dropout=dropout,
- context_dim=context_dim,
- img_cross_attention=img_cross_attention,
- disable_self_attn=disable_self_attn,
- checkpoint=use_checkpoint) for d in range(depth)
- ])
- if not use_linear:
- self.proj_out = zero_module(nn.Conv2d(inner_dim, in_channels, kernel_size=1, stride=1, padding=0))
- else:
- self.proj_out = zero_module(nn.Linear(inner_dim, in_channels))
- self.use_linear = use_linear
-
-
- def forward(self, x, context=None):
- b, c, h, w = x.shape
- x_in = x
- x = self.norm(x)
- if not self.use_linear:
- x = self.proj_in(x)
- x = rearrange(x, 'b c h w -> b (h w) c').contiguous()
- if self.use_linear:
- x = self.proj_in(x)
- for i, block in enumerate(self.transformer_blocks):
- x = block(x, context=context)
- if self.use_linear:
- x = self.proj_out(x)
- x = rearrange(x, 'b (h w) c -> b c h w', h=h, w=w).contiguous()
- if not self.use_linear:
- x = self.proj_out(x)
- return x + x_in
-
-
-class TemporalTransformer(nn.Module):
- """
- Transformer block for image-like data in temporal axis.
- First, reshape to b, t, d.
- Then apply standard transformer action.
- Finally, reshape to image
- """
- def __init__(self, in_channels, n_heads, d_head, depth=1, dropout=0., context_dim=None,
- use_checkpoint=True, use_linear=False, only_self_att=True, causal_attention=False,
- relative_position=False, temporal_length=None):
- super().__init__()
- self.only_self_att = only_self_att
- self.relative_position = relative_position
- self.causal_attention = causal_attention
- self.in_channels = in_channels
- inner_dim = n_heads * d_head
- self.norm = torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
- self.proj_in = nn.Conv1d(in_channels, inner_dim, kernel_size=1, stride=1, padding=0)
- if not use_linear:
- self.proj_in = nn.Conv1d(in_channels, inner_dim, kernel_size=1, stride=1, padding=0)
- else:
- self.proj_in = nn.Linear(in_channels, inner_dim)
-
- if relative_position:
- assert(temporal_length is not None)
- attention_cls = partial(CrossAttention, relative_position=True, temporal_length=temporal_length)
- else:
- attention_cls = None
- if self.causal_attention:
- assert(temporal_length is not None)
- self.mask = torch.tril(torch.ones([1, temporal_length, temporal_length]))
-
- if self.only_self_att:
- context_dim = None
- self.transformer_blocks = nn.ModuleList([
- BasicTransformerBlock(
- inner_dim,
- n_heads,
- d_head,
- dropout=dropout,
- context_dim=context_dim,
- attention_cls=attention_cls,
- checkpoint=use_checkpoint) for d in range(depth)
- ])
- if not use_linear:
- self.proj_out = zero_module(nn.Conv1d(inner_dim, in_channels, kernel_size=1, stride=1, padding=0))
- else:
- self.proj_out = zero_module(nn.Linear(inner_dim, in_channels))
- self.use_linear = use_linear
-
- def forward(self, x, context=None):
- b, c, t, h, w = x.shape
- x_in = x
- x = self.norm(x)
- x = rearrange(x, 'b c t h w -> (b h w) c t').contiguous()
- if not self.use_linear:
- x = self.proj_in(x)
- x = rearrange(x, 'bhw c t -> bhw t c').contiguous()
- if self.use_linear:
- x = self.proj_in(x)
-
- if self.causal_attention:
- mask = self.mask.to(x.device)
- mask = repeat(mask, 'l i j -> (l bhw) i j', bhw=b*h*w)
- else:
- mask = None
-
- if self.only_self_att:
- ## note: if no context is given, cross-attention defaults to self-attention
- for i, block in enumerate(self.transformer_blocks):
- x = block(x, mask=mask)
- x = rearrange(x, '(b hw) t c -> b hw t c', b=b).contiguous()
- else:
- x = rearrange(x, '(b hw) t c -> b hw t c', b=b).contiguous()
- context = rearrange(context, '(b t) l con -> b t l con', t=t).contiguous()
- for i, block in enumerate(self.transformer_blocks):
- # calculate each batch one by one (since number in shape could not greater then 65,535 for some package)
- for j in range(b):
- context_j = repeat(
- context[j],
- 't l con -> (t r) l con', r=(h * w) // t, t=t).contiguous()
- ## note: causal mask will not applied in cross-attention case
- x[j] = block(x[j], context=context_j)
-
- if self.use_linear:
- x = self.proj_out(x)
- x = rearrange(x, 'b (h w) t c -> b c t h w', h=h, w=w).contiguous()
- if not self.use_linear:
- x = rearrange(x, 'b hw t c -> (b hw) c t').contiguous()
- x = self.proj_out(x)
- x = rearrange(x, '(b h w) c t -> b c t h w', b=b, h=h, w=w).contiguous()
-
- return x + x_in
-
-
-class GEGLU(nn.Module):
- def __init__(self, dim_in, dim_out):
- super().__init__()
- self.proj = nn.Linear(dim_in, dim_out * 2)
-
- def forward(self, x):
- x, gate = self.proj(x).chunk(2, dim=-1)
- return x * F.gelu(gate)
-
-
-class FeedForward(nn.Module):
- def __init__(self, dim, dim_out=None, mult=4, glu=False, dropout=0.):
- super().__init__()
- inner_dim = int(dim * mult)
- dim_out = default(dim_out, dim)
- project_in = nn.Sequential(
- nn.Linear(dim, inner_dim),
- nn.GELU()
- ) if not glu else GEGLU(dim, inner_dim)
-
- self.net = nn.Sequential(
- project_in,
- nn.Dropout(dropout),
- nn.Linear(inner_dim, dim_out)
- )
-
- def forward(self, x):
- return self.net(x)
-
-
-class LinearAttention(nn.Module):
- def __init__(self, dim, heads=4, dim_head=32):
- super().__init__()
- self.heads = heads
- hidden_dim = dim_head * heads
- self.to_qkv = nn.Conv2d(dim, hidden_dim * 3, 1, bias = False)
- self.to_out = nn.Conv2d(hidden_dim, dim, 1)
-
- def forward(self, x):
- b, c, h, w = x.shape
- qkv = self.to_qkv(x)
- q, k, v = rearrange(qkv, 'b (qkv heads c) h w -> qkv b heads c (h w)', heads = self.heads, qkv=3)
- k = k.softmax(dim=-1)
- context = torch.einsum('bhdn,bhen->bhde', k, v)
- out = torch.einsum('bhde,bhdn->bhen', context, q)
- out = rearrange(out, 'b heads c (h w) -> b (heads c) h w', heads=self.heads, h=h, w=w)
- return self.to_out(out)
-
-
-class SpatialSelfAttention(nn.Module):
- def __init__(self, in_channels):
- super().__init__()
- self.in_channels = in_channels
-
- self.norm = torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
- self.q = torch.nn.Conv2d(in_channels,
- in_channels,
- kernel_size=1,
- stride=1,
- padding=0)
- self.k = torch.nn.Conv2d(in_channels,
- in_channels,
- kernel_size=1,
- stride=1,
- padding=0)
- self.v = torch.nn.Conv2d(in_channels,
- in_channels,
- kernel_size=1,
- stride=1,
- padding=0)
- self.proj_out = torch.nn.Conv2d(in_channels,
- in_channels,
- kernel_size=1,
- stride=1,
- padding=0)
-
- def forward(self, x):
- h_ = x
- h_ = self.norm(h_)
- q = self.q(h_)
- k = self.k(h_)
- v = self.v(h_)
-
- # compute attention
- b,c,h,w = q.shape
- q = rearrange(q, 'b c h w -> b (h w) c')
- k = rearrange(k, 'b c h w -> b c (h w)')
- w_ = torch.einsum('bij,bjk->bik', q, k)
-
- w_ = w_ * (int(c)**(-0.5))
- w_ = torch.nn.functional.softmax(w_, dim=2)
-
- # attend to values
- v = rearrange(v, 'b c h w -> b c (h w)')
- w_ = rearrange(w_, 'b i j -> b j i')
- h_ = torch.einsum('bij,bjk->bik', v, w_)
- h_ = rearrange(h_, 'b c (h w) -> b c h w', h=h)
- h_ = self.proj_out(h_)
-
- return x+h_
diff --git a/spaces/Willow123/InternLM-XComposer/demo_asset/conversation.py b/spaces/Willow123/InternLM-XComposer/demo_asset/conversation.py
deleted file mode 100644
index ce285299a1281a93ff24a7226c101b5dd9ba75b9..0000000000000000000000000000000000000000
--- a/spaces/Willow123/InternLM-XComposer/demo_asset/conversation.py
+++ /dev/null
@@ -1,160 +0,0 @@
-from PIL import Image
-
-import torch
-from transformers import StoppingCriteria, StoppingCriteriaList
-
-import dataclasses
-from enum import auto, Enum
-from typing import List, Any
-
-
-class SeparatorStyle(Enum):
- """Different separator style."""
- SINGLE = auto()
- TWO = auto()
-
-
-@dataclasses.dataclass
-class Conversation:
- """A class that keeps all conversation history."""
- system: str
- roles: List[str]
- messages: List[List[str]]
- offset: int
- # system_img: List[Image.Image] = []
- sep_style: SeparatorStyle = SeparatorStyle.SINGLE
- sep: str = "###"
- sep2: str = None
-
- skip_next: bool = False
- conv_id: Any = None
-
- def get_prompt(self):
- if self.sep_style == SeparatorStyle.SINGLE:
- ret = self.system + self.sep
- for role, message in self.messages:
- if message:
- #ret += role + ": " + message + self.sep
- ret += role + ":" + message + self.sep
- else:
- ret += role + ":"
- return ret
- elif self.sep_style == SeparatorStyle.TWO:
- seps = [self.sep, self.sep2]
- ret = self.system + seps[0]
- for i, (role, message) in enumerate(self.messages):
- if message:
- ret += role + ": " + message[0] + seps[i % 2] if isinstance(message, list) else role + ": " + message + seps[i % 2]
- else:
- ret += role + ":"
- return ret
- elif self.sep_style == "7132":
- seps = [self.sep, self.sep2]
- ret = self.system
- for i, (role, message) in enumerate(self.messages):
- if message:
- ret += role + ": " + message[0] + seps[i % 2] if isinstance(message, list) else role + ": " + message + seps[i % 2]
- else:
- ret += role + ":"
- return ret
- elif self.sep_style == "raw":
- seps = [self.sep, self.sep2]
- ret = self.system
- for i, (role, message) in enumerate(self.messages):
- if message:
- ret += role + message + seps[i % 2]
- else:
- ret += role
- return ret
-
- else:
- raise ValueError(f"Invalid style: {self.sep_style}")
-
- def append_message(self, role, message):
- self.messages.append([role, message])
-
- def to_gradio_chatbot(self):
- ret = []
- for i, (role, msg) in enumerate(self.messages[self.offset:]):
- if i % 2 == 0:
- if type(msg) is tuple or type(msg) is list:
- import base64
- from io import BytesIO
- msg, image = msg
-
- max_hw, min_hw = max(image.size), min(image.size)
- aspect_ratio = max_hw / min_hw
- max_len, min_len = 800, 400
- shortest_edge = int(min(max_len / aspect_ratio, min_len, min_hw))
- longest_edge = int(shortest_edge * aspect_ratio)
- W, H = image.size
- if H > W:
- H, W = longest_edge, shortest_edge
- else:
- H, W = shortest_edge, longest_edge
- image = image.resize((W, H))
- # image = image.resize((224, 224))
- buffered = BytesIO()
- image.save(buffered, format="JPEG")
- img_b64_str = base64.b64encode(buffered.getvalue()).decode()
- img_str = f''
- msg = msg.replace('![]()
', img_str)
- ret.append([msg, None])
- else:
- ret[-1][-1] = msg
- return ret
-
- def copy(self):
- return Conversation(
- system=self.system,
- # system_img=self.system_img,
- roles=self.roles,
- messages=[[x, y] for x, y in self.messages],
- offset=self.offset,
- sep_style=self.sep_style,
- sep=self.sep,
- sep2=self.sep2,
- conv_id=self.conv_id)
-
- def dict(self):
- return {
- "system": self.system,
- # "system_img": self.system_img,
- "roles": self.roles,
- "messages": self.messages,
- "offset": self.offset,
- "sep": self.sep,
- "sep2": self.sep2,
- "conv_id": self.conv_id,
- }
-
-
-class StoppingCriteriaSub(StoppingCriteria):
-
- def __init__(self, stops=[], encounters=1):
- super().__init__()
- self.stops = stops
-
- def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor):
- for stop in self.stops:
- if torch.all((stop == input_ids[0][-len(stop):])).item():
- return True
-
- return False
-
-
-meta = """meta instruction
-You are an AI assistant whose name is 浦语.
-- 浦语 is a conversational language model that is developed by Shanghai AI Laboratory (上海人工智能实验室). It is designed to be helpful, honest, and harmless.
-- 浦语 can understand and communicate fluently in the language chosen by the user such as English and 中文.
-conversation
-"""
-CONV_VISION_7132_v2 = Conversation(
- system=meta,
- roles=(" <|User|>", " <|Bot|>"),
- messages=(),
- offset=0,
- sep_style="7132",
- sep="",
- sep2="",
-)
diff --git a/spaces/Yan233th/so-vits-svc-models/resample.py b/spaces/Yan233th/so-vits-svc-models/resample.py
deleted file mode 100644
index f84119cd239b49d260ed1d9e367206adcc3aa03d..0000000000000000000000000000000000000000
--- a/spaces/Yan233th/so-vits-svc-models/resample.py
+++ /dev/null
@@ -1,48 +0,0 @@
-import os
-import argparse
-import librosa
-import numpy as np
-from multiprocessing import Pool, cpu_count
-from scipy.io import wavfile
-from tqdm import tqdm
-
-
-def process(item):
- spkdir, wav_name, args = item
- # speaker 's5', 'p280', 'p315' are excluded,
- speaker = spkdir.replace("\\", "/").split("/")[-1]
- wav_path = os.path.join(args.in_dir, speaker, wav_name)
- if os.path.exists(wav_path) and '.wav' in wav_path:
- os.makedirs(os.path.join(args.out_dir2, speaker), exist_ok=True)
- wav, sr = librosa.load(wav_path, sr=None)
- wav, _ = librosa.effects.trim(wav, top_db=20)
- peak = np.abs(wav).max()
- if peak > 1.0:
- wav = 0.98 * wav / peak
- wav2 = librosa.resample(wav, orig_sr=sr, target_sr=args.sr2)
- wav2 /= max(wav2.max(), -wav2.min())
- save_name = wav_name
- save_path2 = os.path.join(args.out_dir2, speaker, save_name)
- wavfile.write(
- save_path2,
- args.sr2,
- (wav2 * np.iinfo(np.int16).max).astype(np.int16)
- )
-
-
-
-if __name__ == "__main__":
- parser = argparse.ArgumentParser()
- parser.add_argument("--sr2", type=int, default=44100, help="sampling rate")
- parser.add_argument("--in_dir", type=str, default="./dataset_raw", help="path to source dir")
- parser.add_argument("--out_dir2", type=str, default="./dataset/44k", help="path to target dir")
- args = parser.parse_args()
- processs = cpu_count()-2 if cpu_count() >4 else 1
- pool = Pool(processes=processs)
-
- for speaker in os.listdir(args.in_dir):
- spk_dir = os.path.join(args.in_dir, speaker)
- if os.path.isdir(spk_dir):
- print(spk_dir)
- for _ in tqdm(pool.imap_unordered(process, [(spk_dir, i, args) for i in os.listdir(spk_dir) if i.endswith("wav")])):
- pass
diff --git a/spaces/Yiqin/ChatVID/model/fastchat/conversation.py b/spaces/Yiqin/ChatVID/model/fastchat/conversation.py
deleted file mode 100644
index 6d5555dfe30df5c0193ffd7edf0a0e03f51b78ed..0000000000000000000000000000000000000000
--- a/spaces/Yiqin/ChatVID/model/fastchat/conversation.py
+++ /dev/null
@@ -1,289 +0,0 @@
-"""
-Conversation prompt template.
-
-Now we support
-- Vicuna
-- Koala
-- OpenAssistant/oasst-sft-1-pythia-12b
-- StabilityAI/stablelm-tuned-alpha-7b
-- databricks/dolly-v2-12b
-- THUDM/chatglm-6b
-- project-baize/baize-lora-7B
-- Alpaca/LLaMa
-"""
-
-import dataclasses
-from enum import auto, Enum
-from typing import List, Tuple, Any
-
-
-class SeparatorStyle(Enum):
- """Different separator style."""
-
- SINGLE = auto()
- TWO = auto()
- DOLLY = auto()
- OASST_PYTHIA = auto()
- BAIZE = auto()
-
-
-@dataclasses.dataclass
-class Conversation:
- """A class that keeps all conversation history."""
-
- system: str
- roles: List[str]
- messages: List[List[str]]
- offset: int
- sep_style: SeparatorStyle = SeparatorStyle.SINGLE
- sep: str = "###"
- sep2: str = None
-
- # Used for gradio server
- skip_next: bool = False
- conv_id: Any = None
-
- def get_prompt(self):
- if self.sep_style == SeparatorStyle.SINGLE:
- ret = self.system
- for role, message in self.messages:
- if message:
- ret += self.sep + " " + role + ": " + message
- else:
- ret += self.sep + " " + role + ":"
- return ret
- elif self.sep_style == SeparatorStyle.TWO:
- seps = [self.sep, self.sep2]
- ret = self.system + seps[0]
- for i, (role, message) in enumerate(self.messages):
- if message:
- ret += role + ": " + message + seps[i % 2]
- else:
- ret += role + ":"
- return ret
- elif self.sep_style == SeparatorStyle.DOLLY:
- seps = [self.sep, self.sep2]
- ret = self.system
- for i, (role, message) in enumerate(self.messages):
- if message:
- ret += role + ":\n" + message + seps[i % 2]
- if i % 2 == 1:
- ret += "\n\n"
- else:
- ret += role + ":\n"
- return ret
- elif self.sep_style == SeparatorStyle.OASST_PYTHIA:
- ret = self.system
- for role, message in self.messages:
- if message:
- ret += role + message + self.sep
- else:
- ret += role
- return ret
- elif self.sep_style == SeparatorStyle.BAIZE:
- ret = self.system
- for role, message in self.messages:
- if message:
- ret += "\n" + role + message
- else:
- ret += "\n" + role
- return ret
- else:
- raise ValueError(f"Invalid style: {self.sep_style}")
-
- def append_message(self, role, message):
- self.messages.append([role, message])
-
- def to_gradio_chatbot(self):
- ret = []
- for i, (role, msg) in enumerate(self.messages[self.offset :]):
- if i % 2 == 0:
- ret.append([msg, None])
- else:
- ret[-1][-1] = msg
- return ret
-
- def copy(self):
- return Conversation(
- system=self.system,
- roles=self.roles,
- messages=[[x, y] for x, y in self.messages],
- offset=self.offset,
- sep_style=self.sep_style,
- sep=self.sep,
- sep2=self.sep2,
- conv_id=self.conv_id,
- )
-
- def dict(self):
- return {
- "system": self.system,
- "roles": self.roles,
- "messages": self.messages,
- "offset": self.offset,
- "sep": self.sep,
- "sep2": self.sep2,
- "conv_id": self.conv_id,
- }
-
-
-conv_one_shot = Conversation(
- system="A chat between a curious human and an artificial intelligence assistant. "
- "The assistant gives helpful, detailed, and polite answers to the human's questions.",
- roles=("Human", "Assistant"),
- messages=(
- (
- "Human",
- "What are the key differences between renewable and non-renewable energy sources?",
- ),
- (
- "Assistant",
- "Renewable energy sources are those that can be replenished naturally in a relatively "
- "short amount of time, such as solar, wind, hydro, geothermal, and biomass. "
- "Non-renewable energy sources, on the other hand, are finite and will eventually be "
- "depleted, such as coal, oil, and natural gas. Here are some key differences between "
- "renewable and non-renewable energy sources:\n"
- "1. Availability: Renewable energy sources are virtually inexhaustible, while non-renewable "
- "energy sources are finite and will eventually run out.\n"
- "2. Environmental impact: Renewable energy sources have a much lower environmental impact "
- "than non-renewable sources, which can lead to air and water pollution, greenhouse gas emissions, "
- "and other negative effects.\n"
- "3. Cost: Renewable energy sources can be more expensive to initially set up, but they typically "
- "have lower operational costs than non-renewable sources.\n"
- "4. Reliability: Renewable energy sources are often more reliable and can be used in more remote "
- "locations than non-renewable sources.\n"
- "5. Flexibility: Renewable energy sources are often more flexible and can be adapted to different "
- "situations and needs, while non-renewable sources are more rigid and inflexible.\n"
- "6. Sustainability: Renewable energy sources are more sustainable over the long term, while "
- "non-renewable sources are not, and their depletion can lead to economic and social instability.",
- ),
- ),
- offset=2,
- sep_style=SeparatorStyle.SINGLE,
- sep="###",
-)
-
-
-conv_vicuna_v1_1 = Conversation(
- system="A chat between a curious user and an artificial intelligence assistant. "
- "The assistant gives helpful, detailed, and polite answers to the user's questions.",
- roles=("USER", "ASSISTANT"),
- messages=(),
- offset=0,
- sep_style=SeparatorStyle.TWO,
- sep=" ",
- sep2="",
-)
-
-
-conv_koala_v1 = Conversation(
- system="BEGINNING OF CONVERSATION:",
- roles=("USER", "GPT"),
- messages=(),
- offset=0,
- sep_style=SeparatorStyle.TWO,
- sep=" ",
- sep2="",
-)
-
-conv_dolly = Conversation(
- system="Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n",
- roles=("### Instruction", "### Response"),
- messages=(),
- offset=0,
- sep_style=SeparatorStyle.DOLLY,
- sep="\n\n",
- sep2="### End",
-)
-
-conv_oasst = Conversation(
- system="",
- roles=("<|prompter|>", "<|assistant|>"),
- messages=(),
- offset=0,
- sep_style=SeparatorStyle.OASST_PYTHIA,
- sep="<|endoftext|>",
-)
-
-conv_stablelm = Conversation(
- system="""<|SYSTEM|># StableLM Tuned (Alpha version)
-- StableLM is a helpful and harmless open-source AI language model developed by StabilityAI.
-- StableLM is excited to be able to help the user, but will refuse to do anything that could be considered harmful to the user.
-- StableLM is more than just an information source, StableLM is also able to write poetry, short stories, and make jokes.
-- StableLM will refuse to participate in anything that could harm a human.
-""",
- roles=("<|USER|>", "<|ASSISTANT|>"),
- messages=(),
- offset=0,
- sep_style=SeparatorStyle.OASST_PYTHIA,
- sep="",
-)
-
-conv_baize = Conversation(
- system="The following is a conversation between a human and an AI assistant named Baize (named after a mythical creature in Chinese folklore). Baize is an open-source AI assistant developed by UCSD and Sun Yat-Sen University. The human and the AI assistant take turns chatting. Human statements start with [|Human|] and AI assistant statements start with [|AI|]. The AI assistant always provides responses in as much detail as possible, and in Markdown format. The AI assistant always declines to engage with topics, questions and instructions related to unethical, controversial, or sensitive issues. Complete the transcript in exactly that format.",
- roles=("[|Human|]", "[|AI|]"),
- messages=(
- ("[|Human|]", "Hello!"),
- ("[|AI|]", "Hi!"),
- ),
- offset=2,
- sep_style=SeparatorStyle.BAIZE,
- sep="[|Human|]",
-)
-
-
-conv_templates = {
- "conv_one_shot": conv_one_shot,
- "vicuna_v1.1": conv_vicuna_v1_1,
- "koala_v1": conv_koala_v1,
- "dolly": conv_dolly,
- "oasst": conv_oasst,
- "baize": conv_baize,
-}
-
-
-def get_default_conv_template(model_name):
- model_name = model_name.lower()
- if "vicuna" in model_name or "output" in model_name:
- return conv_vicuna_v1_1
- elif "koala" in model_name:
- return conv_koala_v1
- elif "dolly-v2" in model_name:
- return conv_dolly
- elif "oasst" in model_name and "pythia" in model_name:
- return conv_oasst
- elif "baize" in model_name:
- return conv_baize
- elif "stablelm" in model_name:
- return conv_stablelm
- return conv_one_shot
-
-
-def compute_skip_echo_len(model_name, conv, prompt):
- model_name = model_name.lower()
- if "chatglm" in model_name:
- skip_echo_len = len(conv.messages[-2][1]) + 1
- elif "dolly-v2" in model_name:
- special_toks = ["### Instruction:", "### Response:", "### End"]
- skip_echo_len = len(prompt)
- for tok in special_toks:
- skip_echo_len -= prompt.count(tok) * len(tok)
- elif "oasst" in model_name and "pythia" in model_name:
- special_toks = ["<|prompter|>", "<|assistant|>", "<|endoftext|>"]
- skip_echo_len = len(prompt)
- for tok in special_toks:
- skip_echo_len -= prompt.count(tok) * len(tok)
- elif "stablelm" in model_name:
- special_toks = ["<|SYSTEM|>", "<|USER|>", "<|ASSISTANT|>"]
- skip_echo_len = len(prompt)
- for tok in special_toks:
- skip_echo_len -= prompt.count(tok) * len(tok)
- elif "baize" in model_name:
- skip_echo_len = len(prompt)
- else:
- skip_echo_len = len(prompt) + 1 - prompt.count("") * 3
- return skip_echo_len
-
-
-if __name__ == "__main__":
- print(default_conversation.get_prompt())
diff --git a/spaces/Yiqin/ChatVID/model/vision/grit_src/grit/data/transforms/custom_augmentation_impl.py b/spaces/Yiqin/ChatVID/model/vision/grit_src/grit/data/transforms/custom_augmentation_impl.py
deleted file mode 100644
index 6b9637f3ad41e3ba513636219e49371296d9ab9f..0000000000000000000000000000000000000000
--- a/spaces/Yiqin/ChatVID/model/vision/grit_src/grit/data/transforms/custom_augmentation_impl.py
+++ /dev/null
@@ -1,52 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-# Part of the code is from https://github.com/rwightman/efficientdet-pytorch/blob/master/effdet/data/transforms.py
-# Modified by Xingyi Zhou
-# The original code is under Apache-2.0 License
-import numpy as np
-from PIL import Image
-
-from detectron2.data.transforms.augmentation import Augmentation
-from .custom_transform import EfficientDetResizeCropTransform
-
-__all__ = [
- "EfficientDetResizeCrop",
-]
-
-
-class EfficientDetResizeCrop(Augmentation):
- """
- Scale the shorter edge to the given size, with a limit of `max_size` on the longer edge.
- If `max_size` is reached, then downscale so that the longer edge does not exceed max_size.
- """
-
- def __init__(
- self, size, scale, interp=Image.BILINEAR
- ):
- """
- """
- super().__init__()
- self.target_size = (size, size)
- self.scale = scale
- self.interp = interp
-
- def get_transform(self, img):
- # Select a random scale factor.
- scale_factor = np.random.uniform(*self.scale)
- scaled_target_height = scale_factor * self.target_size[0]
- scaled_target_width = scale_factor * self.target_size[1]
- # Recompute the accurate scale_factor using rounded scaled image size.
- width, height = img.shape[1], img.shape[0]
- img_scale_y = scaled_target_height / height
- img_scale_x = scaled_target_width / width
- img_scale = min(img_scale_y, img_scale_x)
-
- # Select non-zero random offset (x, y) if scaled image is larger than target size
- scaled_h = int(height * img_scale)
- scaled_w = int(width * img_scale)
- offset_y = scaled_h - self.target_size[0]
- offset_x = scaled_w - self.target_size[1]
- offset_y = int(max(0.0, float(offset_y)) * np.random.uniform(0, 1))
- offset_x = int(max(0.0, float(offset_x)) * np.random.uniform(0, 1))
- return EfficientDetResizeCropTransform(
- scaled_h, scaled_w, offset_y, offset_x, img_scale, self.target_size, self.interp)
diff --git a/spaces/abdvl/datahub_qa_bot/docs/platform-instances.md b/spaces/abdvl/datahub_qa_bot/docs/platform-instances.md
deleted file mode 100644
index b88b9501b4e0a29f012c5325e509e4935d920e04..0000000000000000000000000000000000000000
--- a/spaces/abdvl/datahub_qa_bot/docs/platform-instances.md
+++ /dev/null
@@ -1,44 +0,0 @@
-# Working With Platform Instances
-
-DataHub's metadata model for Datasets supports a three-part key currently:
-- Data Platform (e.g. urn:li:dataPlatform:mysql)
-- Name (e.g. db.schema.name)
-- Env or Fabric (e.g. DEV, PROD, etc.)
-
-This naming scheme unfortunately does not allow for easy representation of the multiplicity of platforms (or technologies) that might be deployed at an organization within the same environment or fabric. For example, an organization might have multiple Redshift instances in Production and would want to see all the data assets located in those instances inside the DataHub metadata repository.
-
-As part of the `v0.8.24+` releases, we are unlocking the first phase of supporting Platform Instances in the metadata model. This is done via two main additions:
-- The `dataPlatformInstance` aspect that has been added to Datasets which allows datasets to be associated to an instance of a platform
-- Enhancements to all ingestion sources that allow them to attach a platform instance to the recipe that changes the generated urns to go from `urn:li:dataset:(urn:li:dataPlatform:,,ENV)` format to `urn:li:dataset:(urn:li:dataPlatform:,,ENV)` format. Sources that produce lineage to datasets in other platforms (e.g. Looker, Superset etc) also have specific configuration additions that allow the recipe author to specify the mapping between a platform and the instance name that it should be mapped to.
-
-
-
-## Naming Platform Instances
-
-When configuring a platform instance, choose an instance name that is understandable and will be stable for the foreseeable future. e.g. `core_warehouse` or `finance_redshift` are allowed names, as are pure guids like `a37dc708-c512-4fe4-9829-401cd60ed789`. Remember that whatever instance name you choose, you will need to specify it in more than one recipe to ensure that the identifiers produced by different sources will line up.
-
-## Enabling Platform Instances
-
-Read the Ingestion source specific guides for how to enable platform instances in each of them.
-The general pattern is to add an additional optional configuration parameter called `platform_instance`.
-
-e.g. here is how you would configure a recipe to ingest a mysql instance that you want to call `core_finance`
-```yaml
-source:
- type: mysql
- config:
- # Coordinates
- host_port: localhost:3306
- platform_instance: core_finance
- database: dbname
-
- # Credentials
- username: root
- password: example
-
-sink:
- # sink configs
-```
-
-
-##
diff --git a/spaces/abhishek/sketch-to-image/annotator/uniformer_base/mmcv/ops/point_sample.py b/spaces/abhishek/sketch-to-image/annotator/uniformer_base/mmcv/ops/point_sample.py
deleted file mode 100644
index 267f4b3c56630acd85f9bdc630b7be09abab0aba..0000000000000000000000000000000000000000
--- a/spaces/abhishek/sketch-to-image/annotator/uniformer_base/mmcv/ops/point_sample.py
+++ /dev/null
@@ -1,336 +0,0 @@
-# Modified from https://github.com/facebookresearch/detectron2/tree/master/projects/PointRend # noqa
-
-from os import path as osp
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch.nn.modules.utils import _pair
-from torch.onnx.operators import shape_as_tensor
-
-
-def bilinear_grid_sample(im, grid, align_corners=False):
- """Given an input and a flow-field grid, computes the output using input
- values and pixel locations from grid. Supported only bilinear interpolation
- method to sample the input pixels.
-
- Args:
- im (torch.Tensor): Input feature map, shape (N, C, H, W)
- grid (torch.Tensor): Point coordinates, shape (N, Hg, Wg, 2)
- align_corners {bool}: If set to True, the extrema (-1 and 1) are
- considered as referring to the center points of the input’s
- corner pixels. If set to False, they are instead considered as
- referring to the corner points of the input’s corner pixels,
- making the sampling more resolution agnostic.
- Returns:
- torch.Tensor: A tensor with sampled points, shape (N, C, Hg, Wg)
- """
- n, c, h, w = im.shape
- gn, gh, gw, _ = grid.shape
- assert n == gn
-
- x = grid[:, :, :, 0]
- y = grid[:, :, :, 1]
-
- if align_corners:
- x = ((x + 1) / 2) * (w - 1)
- y = ((y + 1) / 2) * (h - 1)
- else:
- x = ((x + 1) * w - 1) / 2
- y = ((y + 1) * h - 1) / 2
-
- x = x.view(n, -1)
- y = y.view(n, -1)
-
- x0 = torch.floor(x).long()
- y0 = torch.floor(y).long()
- x1 = x0 + 1
- y1 = y0 + 1
-
- wa = ((x1 - x) * (y1 - y)).unsqueeze(1)
- wb = ((x1 - x) * (y - y0)).unsqueeze(1)
- wc = ((x - x0) * (y1 - y)).unsqueeze(1)
- wd = ((x - x0) * (y - y0)).unsqueeze(1)
-
- # Apply default for grid_sample function zero padding
- im_padded = F.pad(im, pad=[1, 1, 1, 1], mode='constant', value=0)
- padded_h = h + 2
- padded_w = w + 2
- # save points positions after padding
- x0, x1, y0, y1 = x0 + 1, x1 + 1, y0 + 1, y1 + 1
-
- # Clip coordinates to padded image size
- x0 = torch.where(x0 < 0, torch.tensor(0), x0)
- x0 = torch.where(x0 > padded_w - 1, torch.tensor(padded_w - 1), x0)
- x1 = torch.where(x1 < 0, torch.tensor(0), x1)
- x1 = torch.where(x1 > padded_w - 1, torch.tensor(padded_w - 1), x1)
- y0 = torch.where(y0 < 0, torch.tensor(0), y0)
- y0 = torch.where(y0 > padded_h - 1, torch.tensor(padded_h - 1), y0)
- y1 = torch.where(y1 < 0, torch.tensor(0), y1)
- y1 = torch.where(y1 > padded_h - 1, torch.tensor(padded_h - 1), y1)
-
- im_padded = im_padded.view(n, c, -1)
-
- x0_y0 = (x0 + y0 * padded_w).unsqueeze(1).expand(-1, c, -1)
- x0_y1 = (x0 + y1 * padded_w).unsqueeze(1).expand(-1, c, -1)
- x1_y0 = (x1 + y0 * padded_w).unsqueeze(1).expand(-1, c, -1)
- x1_y1 = (x1 + y1 * padded_w).unsqueeze(1).expand(-1, c, -1)
-
- Ia = torch.gather(im_padded, 2, x0_y0)
- Ib = torch.gather(im_padded, 2, x0_y1)
- Ic = torch.gather(im_padded, 2, x1_y0)
- Id = torch.gather(im_padded, 2, x1_y1)
-
- return (Ia * wa + Ib * wb + Ic * wc + Id * wd).reshape(n, c, gh, gw)
-
-
-def is_in_onnx_export_without_custom_ops():
- from annotator.uniformer.mmcv.ops import get_onnxruntime_op_path
- ort_custom_op_path = get_onnxruntime_op_path()
- return torch.onnx.is_in_onnx_export(
- ) and not osp.exists(ort_custom_op_path)
-
-
-def normalize(grid):
- """Normalize input grid from [-1, 1] to [0, 1]
- Args:
- grid (Tensor): The grid to be normalize, range [-1, 1].
- Returns:
- Tensor: Normalized grid, range [0, 1].
- """
-
- return (grid + 1.0) / 2.0
-
-
-def denormalize(grid):
- """Denormalize input grid from range [0, 1] to [-1, 1]
- Args:
- grid (Tensor): The grid to be denormalize, range [0, 1].
- Returns:
- Tensor: Denormalized grid, range [-1, 1].
- """
-
- return grid * 2.0 - 1.0
-
-
-def generate_grid(num_grid, size, device):
- """Generate regular square grid of points in [0, 1] x [0, 1] coordinate
- space.
-
- Args:
- num_grid (int): The number of grids to sample, one for each region.
- size (tuple(int, int)): The side size of the regular grid.
- device (torch.device): Desired device of returned tensor.
-
- Returns:
- (torch.Tensor): A tensor of shape (num_grid, size[0]*size[1], 2) that
- contains coordinates for the regular grids.
- """
-
- affine_trans = torch.tensor([[[1., 0., 0.], [0., 1., 0.]]], device=device)
- grid = F.affine_grid(
- affine_trans, torch.Size((1, 1, *size)), align_corners=False)
- grid = normalize(grid)
- return grid.view(1, -1, 2).expand(num_grid, -1, -1)
-
-
-def rel_roi_point_to_abs_img_point(rois, rel_roi_points):
- """Convert roi based relative point coordinates to image based absolute
- point coordinates.
-
- Args:
- rois (Tensor): RoIs or BBoxes, shape (N, 4) or (N, 5)
- rel_roi_points (Tensor): Point coordinates inside RoI, relative to
- RoI, location, range (0, 1), shape (N, P, 2)
- Returns:
- Tensor: Image based absolute point coordinates, shape (N, P, 2)
- """
-
- with torch.no_grad():
- assert rel_roi_points.size(0) == rois.size(0)
- assert rois.dim() == 2
- assert rel_roi_points.dim() == 3
- assert rel_roi_points.size(2) == 2
- # remove batch idx
- if rois.size(1) == 5:
- rois = rois[:, 1:]
- abs_img_points = rel_roi_points.clone()
- # To avoid an error during exporting to onnx use independent
- # variables instead inplace computation
- xs = abs_img_points[:, :, 0] * (rois[:, None, 2] - rois[:, None, 0])
- ys = abs_img_points[:, :, 1] * (rois[:, None, 3] - rois[:, None, 1])
- xs += rois[:, None, 0]
- ys += rois[:, None, 1]
- abs_img_points = torch.stack([xs, ys], dim=2)
- return abs_img_points
-
-
-def get_shape_from_feature_map(x):
- """Get spatial resolution of input feature map considering exporting to
- onnx mode.
-
- Args:
- x (torch.Tensor): Input tensor, shape (N, C, H, W)
- Returns:
- torch.Tensor: Spatial resolution (width, height), shape (1, 1, 2)
- """
- if torch.onnx.is_in_onnx_export():
- img_shape = shape_as_tensor(x)[2:].flip(0).view(1, 1, 2).to(
- x.device).float()
- else:
- img_shape = torch.tensor(x.shape[2:]).flip(0).view(1, 1, 2).to(
- x.device).float()
- return img_shape
-
-
-def abs_img_point_to_rel_img_point(abs_img_points, img, spatial_scale=1.):
- """Convert image based absolute point coordinates to image based relative
- coordinates for sampling.
-
- Args:
- abs_img_points (Tensor): Image based absolute point coordinates,
- shape (N, P, 2)
- img (tuple/Tensor): (height, width) of image or feature map.
- spatial_scale (float): Scale points by this factor. Default: 1.
-
- Returns:
- Tensor: Image based relative point coordinates for sampling,
- shape (N, P, 2)
- """
-
- assert (isinstance(img, tuple) and len(img) == 2) or \
- (isinstance(img, torch.Tensor) and len(img.shape) == 4)
-
- if isinstance(img, tuple):
- h, w = img
- scale = torch.tensor([w, h],
- dtype=torch.float,
- device=abs_img_points.device)
- scale = scale.view(1, 1, 2)
- else:
- scale = get_shape_from_feature_map(img)
-
- return abs_img_points / scale * spatial_scale
-
-
-def rel_roi_point_to_rel_img_point(rois,
- rel_roi_points,
- img,
- spatial_scale=1.):
- """Convert roi based relative point coordinates to image based absolute
- point coordinates.
-
- Args:
- rois (Tensor): RoIs or BBoxes, shape (N, 4) or (N, 5)
- rel_roi_points (Tensor): Point coordinates inside RoI, relative to
- RoI, location, range (0, 1), shape (N, P, 2)
- img (tuple/Tensor): (height, width) of image or feature map.
- spatial_scale (float): Scale points by this factor. Default: 1.
-
- Returns:
- Tensor: Image based relative point coordinates for sampling,
- shape (N, P, 2)
- """
-
- abs_img_point = rel_roi_point_to_abs_img_point(rois, rel_roi_points)
- rel_img_point = abs_img_point_to_rel_img_point(abs_img_point, img,
- spatial_scale)
-
- return rel_img_point
-
-
-def point_sample(input, points, align_corners=False, **kwargs):
- """A wrapper around :func:`grid_sample` to support 3D point_coords tensors
- Unlike :func:`torch.nn.functional.grid_sample` it assumes point_coords to
- lie inside ``[0, 1] x [0, 1]`` square.
-
- Args:
- input (Tensor): Feature map, shape (N, C, H, W).
- points (Tensor): Image based absolute point coordinates (normalized),
- range [0, 1] x [0, 1], shape (N, P, 2) or (N, Hgrid, Wgrid, 2).
- align_corners (bool): Whether align_corners. Default: False
-
- Returns:
- Tensor: Features of `point` on `input`, shape (N, C, P) or
- (N, C, Hgrid, Wgrid).
- """
-
- add_dim = False
- if points.dim() == 3:
- add_dim = True
- points = points.unsqueeze(2)
- if is_in_onnx_export_without_custom_ops():
- # If custom ops for onnx runtime not compiled use python
- # implementation of grid_sample function to make onnx graph
- # with supported nodes
- output = bilinear_grid_sample(
- input, denormalize(points), align_corners=align_corners)
- else:
- output = F.grid_sample(
- input, denormalize(points), align_corners=align_corners, **kwargs)
- if add_dim:
- output = output.squeeze(3)
- return output
-
-
-class SimpleRoIAlign(nn.Module):
-
- def __init__(self, output_size, spatial_scale, aligned=True):
- """Simple RoI align in PointRend, faster than standard RoIAlign.
-
- Args:
- output_size (tuple[int]): h, w
- spatial_scale (float): scale the input boxes by this number
- aligned (bool): if False, use the legacy implementation in
- MMDetection, align_corners=True will be used in F.grid_sample.
- If True, align the results more perfectly.
- """
-
- super(SimpleRoIAlign, self).__init__()
- self.output_size = _pair(output_size)
- self.spatial_scale = float(spatial_scale)
- # to be consistent with other RoI ops
- self.use_torchvision = False
- self.aligned = aligned
-
- def forward(self, features, rois):
- num_imgs = features.size(0)
- num_rois = rois.size(0)
- rel_roi_points = generate_grid(
- num_rois, self.output_size, device=rois.device)
-
- if torch.onnx.is_in_onnx_export():
- rel_img_points = rel_roi_point_to_rel_img_point(
- rois, rel_roi_points, features, self.spatial_scale)
- rel_img_points = rel_img_points.reshape(num_imgs, -1,
- *rel_img_points.shape[1:])
- point_feats = point_sample(
- features, rel_img_points, align_corners=not self.aligned)
- point_feats = point_feats.transpose(1, 2)
- else:
- point_feats = []
- for batch_ind in range(num_imgs):
- # unravel batch dim
- feat = features[batch_ind].unsqueeze(0)
- inds = (rois[:, 0].long() == batch_ind)
- if inds.any():
- rel_img_points = rel_roi_point_to_rel_img_point(
- rois[inds], rel_roi_points[inds], feat,
- self.spatial_scale).unsqueeze(0)
- point_feat = point_sample(
- feat, rel_img_points, align_corners=not self.aligned)
- point_feat = point_feat.squeeze(0).transpose(0, 1)
- point_feats.append(point_feat)
-
- point_feats = torch.cat(point_feats, dim=0)
-
- channels = features.size(1)
- roi_feats = point_feats.reshape(num_rois, channels, *self.output_size)
-
- return roi_feats
-
- def __repr__(self):
- format_str = self.__class__.__name__
- format_str += '(output_size={}, spatial_scale={}'.format(
- self.output_size, self.spatial_scale)
- return format_str
diff --git a/spaces/akhaliq/Music_Source_Separation/scripts/2_create_indexes/vctk-musdb18/create_indexes.sh b/spaces/akhaliq/Music_Source_Separation/scripts/2_create_indexes/vctk-musdb18/create_indexes.sh
deleted file mode 100644
index e2a85230b2745cedb2c98a34ed303082bb1ec48a..0000000000000000000000000000000000000000
--- a/spaces/akhaliq/Music_Source_Separation/scripts/2_create_indexes/vctk-musdb18/create_indexes.sh
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/bin/bash
-WORKSPACE=${1:-"./workspaces/bytesep"} # Default workspace directory
-
-echo "WORKSPACE=${WORKSPACE}"
-
-# Users can modify the following config file.
-INDEXES_CONFIG_YAML="scripts/2_create_indexes/vctk-musdb18/configs/speech-accompaniment,sr=44100,chn=2.yaml"
-
-# Create indexes for training.
-python3 bytesep/dataset_creation/create_indexes/create_indexes.py \
- --workspace=$WORKSPACE \
- --config_yaml=$INDEXES_CONFIG_YAML
diff --git a/spaces/akhaliq/VQMIVC/ParallelWaveGAN/parallel_wavegan/distributed/launch.py b/spaces/akhaliq/VQMIVC/ParallelWaveGAN/parallel_wavegan/distributed/launch.py
deleted file mode 100644
index 292f2a92287bfd201815748465727b76d9a5008e..0000000000000000000000000000000000000000
--- a/spaces/akhaliq/VQMIVC/ParallelWaveGAN/parallel_wavegan/distributed/launch.py
+++ /dev/null
@@ -1,163 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""Distributed process launcher.
-
-This code is modified from https://github.com/pytorch/pytorch/blob/v1.3.0/torch/distributed/launch.py.
-
-"""
-import os
-import subprocess
-import sys
-
-from argparse import ArgumentParser
-from argparse import REMAINDER
-
-
-def parse_args():
- """Parse arguments."""
- parser = ArgumentParser(
- description="PyTorch distributed training launch "
- "helper utilty that will spawn up "
- "multiple distributed processes"
- )
-
- # Optional arguments for the launch helper
- parser.add_argument(
- "--nnodes",
- type=int,
- default=1,
- help="The number of nodes to use for distributed " "training",
- )
- parser.add_argument(
- "--node_rank",
- type=int,
- default=0,
- help="The rank of the node for multi-node distributed " "training",
- )
- parser.add_argument(
- "--nproc_per_node",
- type=int,
- default=1,
- help="The number of processes to launch on each node, "
- "for GPU training, this is recommended to be set "
- "to the number of GPUs in your system so that "
- "each process can be bound to a single GPU.",
- )
- parser.add_argument(
- "--master_addr",
- default="127.0.0.1",
- type=str,
- help="Master node (rank 0)'s address, should be either "
- "the IP address or the hostname of node 0, for "
- "single node multi-proc training, the "
- "--master_addr can simply be 127.0.0.1",
- )
- parser.add_argument(
- "--master_port",
- default=29500,
- type=int,
- help="Master node (rank 0)'s free port that needs to "
- "be used for communciation during distributed "
- "training",
- )
- parser.add_argument(
- "--use_env",
- default=False,
- action="store_true",
- help="Use environment variable to pass "
- "'local rank'. For legacy reasons, the default value is False. "
- "If set to True, the script will not pass "
- "--local_rank as argument, and will instead set LOCAL_RANK.",
- )
- parser.add_argument(
- "-m",
- "--module",
- default=False,
- action="store_true",
- help="Changes each process to interpret the launch script "
- "as a python module, executing with the same behavior as"
- "'python -m'.",
- )
- parser.add_argument(
- "-c",
- "--command",
- default=False,
- action="store_true",
- help="Changes each process to interpret the launch script " "as a command.",
- )
-
- # positional
- parser.add_argument(
- "training_script",
- type=str,
- help="The full path to the single GPU training "
- "program/script/command to be launched in parallel, "
- "followed by all the arguments for the "
- "training script",
- )
-
- # rest from the training program
- parser.add_argument("training_script_args", nargs=REMAINDER)
- return parser.parse_args()
-
-
-def main():
- """Launch distributed processes."""
- args = parse_args()
-
- # world size in terms of number of processes
- dist_world_size = args.nproc_per_node * args.nnodes
-
- # set PyTorch distributed related environmental variables
- current_env = os.environ.copy()
- current_env["MASTER_ADDR"] = args.master_addr
- current_env["MASTER_PORT"] = str(args.master_port)
- current_env["WORLD_SIZE"] = str(dist_world_size)
-
- processes = []
-
- if "OMP_NUM_THREADS" not in os.environ and args.nproc_per_node > 1:
- current_env["OMP_NUM_THREADS"] = str(1)
- print(
- "*****************************************\n"
- "Setting OMP_NUM_THREADS environment variable for each process "
- "to be {} in default, to avoid your system being overloaded, "
- "please further tune the variable for optimal performance in "
- "your application as needed. \n"
- "*****************************************".format(
- current_env["OMP_NUM_THREADS"]
- )
- )
-
- for local_rank in range(0, args.nproc_per_node):
- # each process's rank
- dist_rank = args.nproc_per_node * args.node_rank + local_rank
- current_env["RANK"] = str(dist_rank)
- current_env["LOCAL_RANK"] = str(local_rank)
-
- # spawn the processes
- if args.command:
- cmd = [args.training_script]
- else:
- cmd = [sys.executable, "-u"]
- if args.module:
- cmd.append("-m")
- cmd.append(args.training_script)
-
- if not args.use_env:
- cmd.append("--local_rank={}".format(local_rank))
-
- cmd.extend(args.training_script_args)
-
- process = subprocess.Popen(cmd, env=current_env)
- processes.append(process)
-
- for process in processes:
- process.wait()
- if process.returncode != 0:
- raise subprocess.CalledProcessError(returncode=process.returncode, cmd=cmd)
-
-
-if __name__ == "__main__":
- main()
diff --git a/spaces/akhaliq/lama/bin/make_checkpoint.py b/spaces/akhaliq/lama/bin/make_checkpoint.py
deleted file mode 100644
index 322147483915bef758770ae931e705e56083fa8d..0000000000000000000000000000000000000000
--- a/spaces/akhaliq/lama/bin/make_checkpoint.py
+++ /dev/null
@@ -1,79 +0,0 @@
-#!/usr/bin/env python3
-
-import os
-import shutil
-
-import torch
-
-
-def get_checkpoint_files(s):
- s = s.strip()
- if ',' in s:
- return [get_checkpoint_files(chunk) for chunk in s.split(',')]
- return 'last.ckpt' if s == 'last' else f'{s}.ckpt'
-
-
-def main(args):
- checkpoint_fnames = get_checkpoint_files(args.epochs)
- if isinstance(checkpoint_fnames, str):
- checkpoint_fnames = [checkpoint_fnames]
- assert len(checkpoint_fnames) >= 1
-
- checkpoint_path = os.path.join(args.indir, 'models', checkpoint_fnames[0])
- checkpoint = torch.load(checkpoint_path, map_location='cpu')
- del checkpoint['optimizer_states']
-
- if len(checkpoint_fnames) > 1:
- for fname in checkpoint_fnames[1:]:
- print('sum', fname)
- sum_tensors_cnt = 0
- other_cp = torch.load(os.path.join(args.indir, 'models', fname), map_location='cpu')
- for k in checkpoint['state_dict'].keys():
- if checkpoint['state_dict'][k].dtype is torch.float:
- checkpoint['state_dict'][k].data.add_(other_cp['state_dict'][k].data)
- sum_tensors_cnt += 1
- print('summed', sum_tensors_cnt, 'tensors')
-
- for k in checkpoint['state_dict'].keys():
- if checkpoint['state_dict'][k].dtype is torch.float:
- checkpoint['state_dict'][k].data.mul_(1 / float(len(checkpoint_fnames)))
-
- state_dict = checkpoint['state_dict']
-
- if not args.leave_discriminators:
- for k in list(state_dict.keys()):
- if k.startswith('discriminator.'):
- del state_dict[k]
-
- if not args.leave_losses:
- for k in list(state_dict.keys()):
- if k.startswith('loss_'):
- del state_dict[k]
-
- out_checkpoint_path = os.path.join(args.outdir, 'models', 'best.ckpt')
- os.makedirs(os.path.dirname(out_checkpoint_path), exist_ok=True)
-
- torch.save(checkpoint, out_checkpoint_path)
-
- shutil.copy2(os.path.join(args.indir, 'config.yaml'),
- os.path.join(args.outdir, 'config.yaml'))
-
-
-if __name__ == '__main__':
- import argparse
-
- aparser = argparse.ArgumentParser()
- aparser.add_argument('indir',
- help='Path to directory with output of training '
- '(i.e. directory, which has samples, modules, config.yaml and train.log')
- aparser.add_argument('outdir',
- help='Where to put minimal checkpoint, which can be consumed by "bin/predict.py"')
- aparser.add_argument('--epochs', type=str, default='last',
- help='Which checkpoint to take. '
- 'Can be "last" or integer - number of epoch')
- aparser.add_argument('--leave-discriminators', action='store_true',
- help='If enabled, the state of discriminators will not be removed from the checkpoint')
- aparser.add_argument('--leave-losses', action='store_true',
- help='If enabled, weights of nn-based losses (e.g. perceptual) will not be removed')
-
- main(aparser.parse_args())
diff --git a/spaces/akhaliq/neural-waveshaping-synthesis/neural_waveshaping_synthesis/__init__.py b/spaces/akhaliq/neural-waveshaping-synthesis/neural_waveshaping_synthesis/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/akhaliq/supermarionation/README.md b/spaces/akhaliq/supermarionation/README.md
deleted file mode 100644
index d29e178c9e1d52ff9f6314426a783e72253c1668..0000000000000000000000000000000000000000
--- a/spaces/akhaliq/supermarionation/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Supermarionation
-emoji: 🐨
-colorFrom: pink
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.12.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/alexray/btc_predictor/venv/lib/python3.10/site-packages/pip/_vendor/chardet/charsetgroupprober.py b/spaces/alexray/btc_predictor/venv/lib/python3.10/site-packages/pip/_vendor/chardet/charsetgroupprober.py
deleted file mode 100644
index 5812cef0b5924db9af2da77f0abe4e63decee4cf..0000000000000000000000000000000000000000
--- a/spaces/alexray/btc_predictor/venv/lib/python3.10/site-packages/pip/_vendor/chardet/charsetgroupprober.py
+++ /dev/null
@@ -1,107 +0,0 @@
-######################## BEGIN LICENSE BLOCK ########################
-# The Original Code is Mozilla Communicator client code.
-#
-# The Initial Developer of the Original Code is
-# Netscape Communications Corporation.
-# Portions created by the Initial Developer are Copyright (C) 1998
-# the Initial Developer. All Rights Reserved.
-#
-# Contributor(s):
-# Mark Pilgrim - port to Python
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
-# 02110-1301 USA
-######################### END LICENSE BLOCK #########################
-
-from .enums import ProbingState
-from .charsetprober import CharSetProber
-
-
-class CharSetGroupProber(CharSetProber):
- def __init__(self, lang_filter=None):
- super(CharSetGroupProber, self).__init__(lang_filter=lang_filter)
- self._active_num = 0
- self.probers = []
- self._best_guess_prober = None
-
- def reset(self):
- super(CharSetGroupProber, self).reset()
- self._active_num = 0
- for prober in self.probers:
- if prober:
- prober.reset()
- prober.active = True
- self._active_num += 1
- self._best_guess_prober = None
-
- @property
- def charset_name(self):
- if not self._best_guess_prober:
- self.get_confidence()
- if not self._best_guess_prober:
- return None
- return self._best_guess_prober.charset_name
-
- @property
- def language(self):
- if not self._best_guess_prober:
- self.get_confidence()
- if not self._best_guess_prober:
- return None
- return self._best_guess_prober.language
-
- def feed(self, byte_str):
- for prober in self.probers:
- if not prober:
- continue
- if not prober.active:
- continue
- state = prober.feed(byte_str)
- if not state:
- continue
- if state == ProbingState.FOUND_IT:
- self._best_guess_prober = prober
- self._state = ProbingState.FOUND_IT
- return self.state
- elif state == ProbingState.NOT_ME:
- prober.active = False
- self._active_num -= 1
- if self._active_num <= 0:
- self._state = ProbingState.NOT_ME
- return self.state
- return self.state
-
- def get_confidence(self):
- state = self.state
- if state == ProbingState.FOUND_IT:
- return 0.99
- elif state == ProbingState.NOT_ME:
- return 0.01
- best_conf = 0.0
- self._best_guess_prober = None
- for prober in self.probers:
- if not prober:
- continue
- if not prober.active:
- self.logger.debug('%s not active', prober.charset_name)
- continue
- conf = prober.get_confidence()
- self.logger.debug('%s %s confidence = %s', prober.charset_name, prober.language, conf)
- if best_conf < conf:
- best_conf = conf
- self._best_guess_prober = prober
- if not self._best_guess_prober:
- return 0.0
- return best_conf
diff --git a/spaces/alexray/btc_predictor/venv/lib/python3.10/site-packages/pip/_vendor/chardet/metadata/languages.py b/spaces/alexray/btc_predictor/venv/lib/python3.10/site-packages/pip/_vendor/chardet/metadata/languages.py
deleted file mode 100644
index 3237d5abf60122e0cea5463ff34f2256b11b5a81..0000000000000000000000000000000000000000
--- a/spaces/alexray/btc_predictor/venv/lib/python3.10/site-packages/pip/_vendor/chardet/metadata/languages.py
+++ /dev/null
@@ -1,310 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-Metadata about languages used by our model training code for our
-SingleByteCharSetProbers. Could be used for other things in the future.
-
-This code is based on the language metadata from the uchardet project.
-"""
-from __future__ import absolute_import, print_function
-
-from string import ascii_letters
-
-
-# TODO: Add Ukranian (KOI8-U)
-
-class Language(object):
- """Metadata about a language useful for training models
-
- :ivar name: The human name for the language, in English.
- :type name: str
- :ivar iso_code: 2-letter ISO 639-1 if possible, 3-letter ISO code otherwise,
- or use another catalog as a last resort.
- :type iso_code: str
- :ivar use_ascii: Whether or not ASCII letters should be included in trained
- models.
- :type use_ascii: bool
- :ivar charsets: The charsets we want to support and create data for.
- :type charsets: list of str
- :ivar alphabet: The characters in the language's alphabet. If `use_ascii` is
- `True`, you only need to add those not in the ASCII set.
- :type alphabet: str
- :ivar wiki_start_pages: The Wikipedia pages to start from if we're crawling
- Wikipedia for training data.
- :type wiki_start_pages: list of str
- """
- def __init__(self, name=None, iso_code=None, use_ascii=True, charsets=None,
- alphabet=None, wiki_start_pages=None):
- super(Language, self).__init__()
- self.name = name
- self.iso_code = iso_code
- self.use_ascii = use_ascii
- self.charsets = charsets
- if self.use_ascii:
- if alphabet:
- alphabet += ascii_letters
- else:
- alphabet = ascii_letters
- elif not alphabet:
- raise ValueError('Must supply alphabet if use_ascii is False')
- self.alphabet = ''.join(sorted(set(alphabet))) if alphabet else None
- self.wiki_start_pages = wiki_start_pages
-
- def __repr__(self):
- return '{}({})'.format(self.__class__.__name__,
- ', '.join('{}={!r}'.format(k, v)
- for k, v in self.__dict__.items()
- if not k.startswith('_')))
-
-
-LANGUAGES = {'Arabic': Language(name='Arabic',
- iso_code='ar',
- use_ascii=False,
- # We only support encodings that use isolated
- # forms, because the current recommendation is
- # that the rendering system handles presentation
- # forms. This means we purposefully skip IBM864.
- charsets=['ISO-8859-6', 'WINDOWS-1256',
- 'CP720', 'CP864'],
- alphabet=u'ءآأؤإئابةتثجحخدذرزسشصضطظعغػؼؽؾؿـفقكلمنهوىيًٌٍَُِّ',
- wiki_start_pages=[u'الصفحة_الرئيسية']),
- 'Belarusian': Language(name='Belarusian',
- iso_code='be',
- use_ascii=False,
- charsets=['ISO-8859-5', 'WINDOWS-1251',
- 'IBM866', 'MacCyrillic'],
- alphabet=(u'АБВГДЕЁЖЗІЙКЛМНОПРСТУЎФХЦЧШЫЬЭЮЯ'
- u'абвгдеёжзійклмнопрстуўфхцчшыьэюяʼ'),
- wiki_start_pages=[u'Галоўная_старонка']),
- 'Bulgarian': Language(name='Bulgarian',
- iso_code='bg',
- use_ascii=False,
- charsets=['ISO-8859-5', 'WINDOWS-1251',
- 'IBM855'],
- alphabet=(u'АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЬЮЯ'
- u'абвгдежзийклмнопрстуфхцчшщъьюя'),
- wiki_start_pages=[u'Начална_страница']),
- 'Czech': Language(name='Czech',
- iso_code='cz',
- use_ascii=True,
- charsets=['ISO-8859-2', 'WINDOWS-1250'],
- alphabet=u'áčďéěíňóřšťúůýžÁČĎÉĚÍŇÓŘŠŤÚŮÝŽ',
- wiki_start_pages=[u'Hlavní_strana']),
- 'Danish': Language(name='Danish',
- iso_code='da',
- use_ascii=True,
- charsets=['ISO-8859-1', 'ISO-8859-15',
- 'WINDOWS-1252'],
- alphabet=u'æøåÆØÅ',
- wiki_start_pages=[u'Forside']),
- 'German': Language(name='German',
- iso_code='de',
- use_ascii=True,
- charsets=['ISO-8859-1', 'WINDOWS-1252'],
- alphabet=u'äöüßÄÖÜ',
- wiki_start_pages=[u'Wikipedia:Hauptseite']),
- 'Greek': Language(name='Greek',
- iso_code='el',
- use_ascii=False,
- charsets=['ISO-8859-7', 'WINDOWS-1253'],
- alphabet=(u'αβγδεζηθικλμνξοπρσςτυφχψωάέήίόύώ'
- u'ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΣΤΥΦΧΨΩΆΈΉΊΌΎΏ'),
- wiki_start_pages=[u'Πύλη:Κύρια']),
- 'English': Language(name='English',
- iso_code='en',
- use_ascii=True,
- charsets=['ISO-8859-1', 'WINDOWS-1252'],
- wiki_start_pages=[u'Main_Page']),
- 'Esperanto': Language(name='Esperanto',
- iso_code='eo',
- # Q, W, X, and Y not used at all
- use_ascii=False,
- charsets=['ISO-8859-3'],
- alphabet=(u'abcĉdefgĝhĥijĵklmnoprsŝtuŭvz'
- u'ABCĈDEFGĜHĤIJĴKLMNOPRSŜTUŬVZ'),
- wiki_start_pages=[u'Vikipedio:Ĉefpaĝo']),
- 'Spanish': Language(name='Spanish',
- iso_code='es',
- use_ascii=True,
- charsets=['ISO-8859-1', 'ISO-8859-15',
- 'WINDOWS-1252'],
- alphabet=u'ñáéíóúüÑÁÉÍÓÚÜ',
- wiki_start_pages=[u'Wikipedia:Portada']),
- 'Estonian': Language(name='Estonian',
- iso_code='et',
- use_ascii=False,
- charsets=['ISO-8859-4', 'ISO-8859-13',
- 'WINDOWS-1257'],
- # C, F, Š, Q, W, X, Y, Z, Ž are only for
- # loanwords
- alphabet=(u'ABDEGHIJKLMNOPRSTUVÕÄÖÜ'
- u'abdeghijklmnoprstuvõäöü'),
- wiki_start_pages=[u'Esileht']),
- 'Finnish': Language(name='Finnish',
- iso_code='fi',
- use_ascii=True,
- charsets=['ISO-8859-1', 'ISO-8859-15',
- 'WINDOWS-1252'],
- alphabet=u'ÅÄÖŠŽåäöšž',
- wiki_start_pages=[u'Wikipedia:Etusivu']),
- 'French': Language(name='French',
- iso_code='fr',
- use_ascii=True,
- charsets=['ISO-8859-1', 'ISO-8859-15',
- 'WINDOWS-1252'],
- alphabet=u'œàâçèéîïùûêŒÀÂÇÈÉÎÏÙÛÊ',
- wiki_start_pages=[u'Wikipédia:Accueil_principal',
- u'Bœuf (animal)']),
- 'Hebrew': Language(name='Hebrew',
- iso_code='he',
- use_ascii=False,
- charsets=['ISO-8859-8', 'WINDOWS-1255'],
- alphabet=u'אבגדהוזחטיךכלםמןנסעףפץצקרשתװױײ',
- wiki_start_pages=[u'עמוד_ראשי']),
- 'Croatian': Language(name='Croatian',
- iso_code='hr',
- # Q, W, X, Y are only used for foreign words.
- use_ascii=False,
- charsets=['ISO-8859-2', 'WINDOWS-1250'],
- alphabet=(u'abcčćdđefghijklmnoprsštuvzž'
- u'ABCČĆDĐEFGHIJKLMNOPRSŠTUVZŽ'),
- wiki_start_pages=[u'Glavna_stranica']),
- 'Hungarian': Language(name='Hungarian',
- iso_code='hu',
- # Q, W, X, Y are only used for foreign words.
- use_ascii=False,
- charsets=['ISO-8859-2', 'WINDOWS-1250'],
- alphabet=(u'abcdefghijklmnoprstuvzáéíóöőúüű'
- u'ABCDEFGHIJKLMNOPRSTUVZÁÉÍÓÖŐÚÜŰ'),
- wiki_start_pages=[u'Kezdőlap']),
- 'Italian': Language(name='Italian',
- iso_code='it',
- use_ascii=True,
- charsets=['ISO-8859-1', 'ISO-8859-15',
- 'WINDOWS-1252'],
- alphabet=u'ÀÈÉÌÒÓÙàèéìòóù',
- wiki_start_pages=[u'Pagina_principale']),
- 'Lithuanian': Language(name='Lithuanian',
- iso_code='lt',
- use_ascii=False,
- charsets=['ISO-8859-13', 'WINDOWS-1257',
- 'ISO-8859-4'],
- # Q, W, and X not used at all
- alphabet=(u'AĄBCČDEĘĖFGHIĮYJKLMNOPRSŠTUŲŪVZŽ'
- u'aąbcčdeęėfghiįyjklmnoprsštuųūvzž'),
- wiki_start_pages=[u'Pagrindinis_puslapis']),
- 'Latvian': Language(name='Latvian',
- iso_code='lv',
- use_ascii=False,
- charsets=['ISO-8859-13', 'WINDOWS-1257',
- 'ISO-8859-4'],
- # Q, W, X, Y are only for loanwords
- alphabet=(u'AĀBCČDEĒFGĢHIĪJKĶLĻMNŅOPRSŠTUŪVZŽ'
- u'aābcčdeēfgģhiījkķlļmnņoprsštuūvzž'),
- wiki_start_pages=[u'Sākumlapa']),
- 'Macedonian': Language(name='Macedonian',
- iso_code='mk',
- use_ascii=False,
- charsets=['ISO-8859-5', 'WINDOWS-1251',
- 'MacCyrillic', 'IBM855'],
- alphabet=(u'АБВГДЃЕЖЗЅИЈКЛЉМНЊОПРСТЌУФХЦЧЏШ'
- u'абвгдѓежзѕијклљмнњопрстќуфхцчџш'),
- wiki_start_pages=[u'Главна_страница']),
- 'Dutch': Language(name='Dutch',
- iso_code='nl',
- use_ascii=True,
- charsets=['ISO-8859-1', 'WINDOWS-1252'],
- wiki_start_pages=[u'Hoofdpagina']),
- 'Polish': Language(name='Polish',
- iso_code='pl',
- # Q and X are only used for foreign words.
- use_ascii=False,
- charsets=['ISO-8859-2', 'WINDOWS-1250'],
- alphabet=(u'AĄBCĆDEĘFGHIJKLŁMNŃOÓPRSŚTUWYZŹŻ'
- u'aąbcćdeęfghijklłmnńoóprsśtuwyzźż'),
- wiki_start_pages=[u'Wikipedia:Strona_główna']),
- 'Portuguese': Language(name='Portuguese',
- iso_code='pt',
- use_ascii=True,
- charsets=['ISO-8859-1', 'ISO-8859-15',
- 'WINDOWS-1252'],
- alphabet=u'ÁÂÃÀÇÉÊÍÓÔÕÚáâãàçéêíóôõú',
- wiki_start_pages=[u'Wikipédia:Página_principal']),
- 'Romanian': Language(name='Romanian',
- iso_code='ro',
- use_ascii=True,
- charsets=['ISO-8859-2', 'WINDOWS-1250'],
- alphabet=u'ăâîșțĂÂÎȘȚ',
- wiki_start_pages=[u'Pagina_principală']),
- 'Russian': Language(name='Russian',
- iso_code='ru',
- use_ascii=False,
- charsets=['ISO-8859-5', 'WINDOWS-1251',
- 'KOI8-R', 'MacCyrillic', 'IBM866',
- 'IBM855'],
- alphabet=(u'абвгдеёжзийклмнопрстуфхцчшщъыьэюя'
- u'АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ'),
- wiki_start_pages=[u'Заглавная_страница']),
- 'Slovak': Language(name='Slovak',
- iso_code='sk',
- use_ascii=True,
- charsets=['ISO-8859-2', 'WINDOWS-1250'],
- alphabet=u'áäčďéíĺľňóôŕšťúýžÁÄČĎÉÍĹĽŇÓÔŔŠŤÚÝŽ',
- wiki_start_pages=[u'Hlavná_stránka']),
- 'Slovene': Language(name='Slovene',
- iso_code='sl',
- # Q, W, X, Y are only used for foreign words.
- use_ascii=False,
- charsets=['ISO-8859-2', 'WINDOWS-1250'],
- alphabet=(u'abcčdefghijklmnoprsštuvzž'
- u'ABCČDEFGHIJKLMNOPRSŠTUVZŽ'),
- wiki_start_pages=[u'Glavna_stran']),
- # Serbian can be written in both Latin and Cyrillic, but there's no
- # simple way to get the Latin alphabet pages from Wikipedia through
- # the API, so for now we just support Cyrillic.
- 'Serbian': Language(name='Serbian',
- iso_code='sr',
- alphabet=(u'АБВГДЂЕЖЗИЈКЛЉМНЊОПРСТЋУФХЦЧЏШ'
- u'абвгдђежзијклљмнњопрстћуфхцчџш'),
- charsets=['ISO-8859-5', 'WINDOWS-1251',
- 'MacCyrillic', 'IBM855'],
- wiki_start_pages=[u'Главна_страна']),
- 'Thai': Language(name='Thai',
- iso_code='th',
- use_ascii=False,
- charsets=['ISO-8859-11', 'TIS-620', 'CP874'],
- alphabet=u'กขฃคฅฆงจฉชซฌญฎฏฐฑฒณดตถทธนบปผฝพฟภมยรฤลฦวศษสหฬอฮฯะัาำิีึืฺุู฿เแโใไๅๆ็่้๊๋์ํ๎๏๐๑๒๓๔๕๖๗๘๙๚๛',
- wiki_start_pages=[u'หน้าหลัก']),
- 'Turkish': Language(name='Turkish',
- iso_code='tr',
- # Q, W, and X are not used by Turkish
- use_ascii=False,
- charsets=['ISO-8859-3', 'ISO-8859-9',
- 'WINDOWS-1254'],
- alphabet=(u'abcçdefgğhıijklmnoöprsştuüvyzâîû'
- u'ABCÇDEFGĞHIİJKLMNOÖPRSŞTUÜVYZÂÎÛ'),
- wiki_start_pages=[u'Ana_Sayfa']),
- 'Vietnamese': Language(name='Vietnamese',
- iso_code='vi',
- use_ascii=False,
- # Windows-1258 is the only common 8-bit
- # Vietnamese encoding supported by Python.
- # From Wikipedia:
- # For systems that lack support for Unicode,
- # dozens of 8-bit Vietnamese code pages are
- # available.[1] The most common are VISCII
- # (TCVN 5712:1993), VPS, and Windows-1258.[3]
- # Where ASCII is required, such as when
- # ensuring readability in plain text e-mail,
- # Vietnamese letters are often encoded
- # according to Vietnamese Quoted-Readable
- # (VIQR) or VSCII Mnemonic (VSCII-MNEM),[4]
- # though usage of either variable-width
- # scheme has declined dramatically following
- # the adoption of Unicode on the World Wide
- # Web.
- charsets=['WINDOWS-1258'],
- alphabet=(u'aăâbcdđeêghiklmnoôơpqrstuưvxy'
- u'AĂÂBCDĐEÊGHIKLMNOÔƠPQRSTUƯVXY'),
- wiki_start_pages=[u'Chữ_Quốc_ngữ']),
- }
diff --git a/spaces/allandclive/Uganda_MMS/vits/transforms.py b/spaces/allandclive/Uganda_MMS/vits/transforms.py
deleted file mode 100644
index 4793d67ca5a5630e0ffe0f9fb29445c949e64dae..0000000000000000000000000000000000000000
--- a/spaces/allandclive/Uganda_MMS/vits/transforms.py
+++ /dev/null
@@ -1,193 +0,0 @@
-import torch
-from torch.nn import functional as F
-
-import numpy as np
-
-
-DEFAULT_MIN_BIN_WIDTH = 1e-3
-DEFAULT_MIN_BIN_HEIGHT = 1e-3
-DEFAULT_MIN_DERIVATIVE = 1e-3
-
-
-def piecewise_rational_quadratic_transform(inputs,
- unnormalized_widths,
- unnormalized_heights,
- unnormalized_derivatives,
- inverse=False,
- tails=None,
- tail_bound=1.,
- min_bin_width=DEFAULT_MIN_BIN_WIDTH,
- min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
- min_derivative=DEFAULT_MIN_DERIVATIVE):
-
- if tails is None:
- spline_fn = rational_quadratic_spline
- spline_kwargs = {}
- else:
- spline_fn = unconstrained_rational_quadratic_spline
- spline_kwargs = {
- 'tails': tails,
- 'tail_bound': tail_bound
- }
-
- outputs, logabsdet = spline_fn(
- inputs=inputs,
- unnormalized_widths=unnormalized_widths,
- unnormalized_heights=unnormalized_heights,
- unnormalized_derivatives=unnormalized_derivatives,
- inverse=inverse,
- min_bin_width=min_bin_width,
- min_bin_height=min_bin_height,
- min_derivative=min_derivative,
- **spline_kwargs
- )
- return outputs, logabsdet
-
-
-def searchsorted(bin_locations, inputs, eps=1e-6):
- bin_locations[..., -1] += eps
- return torch.sum(
- inputs[..., None] >= bin_locations,
- dim=-1
- ) - 1
-
-
-def unconstrained_rational_quadratic_spline(inputs,
- unnormalized_widths,
- unnormalized_heights,
- unnormalized_derivatives,
- inverse=False,
- tails='linear',
- tail_bound=1.,
- min_bin_width=DEFAULT_MIN_BIN_WIDTH,
- min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
- min_derivative=DEFAULT_MIN_DERIVATIVE):
- inside_interval_mask = (inputs >= -tail_bound) & (inputs <= tail_bound)
- outside_interval_mask = ~inside_interval_mask
-
- outputs = torch.zeros_like(inputs)
- logabsdet = torch.zeros_like(inputs)
-
- if tails == 'linear':
- unnormalized_derivatives = F.pad(unnormalized_derivatives, pad=(1, 1))
- constant = np.log(np.exp(1 - min_derivative) - 1)
- unnormalized_derivatives[..., 0] = constant
- unnormalized_derivatives[..., -1] = constant
-
- outputs[outside_interval_mask] = inputs[outside_interval_mask]
- logabsdet[outside_interval_mask] = 0
- else:
- raise RuntimeError('{} tails are not implemented.'.format(tails))
-
- outputs[inside_interval_mask], logabsdet[inside_interval_mask] = rational_quadratic_spline(
- inputs=inputs[inside_interval_mask],
- unnormalized_widths=unnormalized_widths[inside_interval_mask, :],
- unnormalized_heights=unnormalized_heights[inside_interval_mask, :],
- unnormalized_derivatives=unnormalized_derivatives[inside_interval_mask, :],
- inverse=inverse,
- left=-tail_bound, right=tail_bound, bottom=-tail_bound, top=tail_bound,
- min_bin_width=min_bin_width,
- min_bin_height=min_bin_height,
- min_derivative=min_derivative
- )
-
- return outputs, logabsdet
-
-def rational_quadratic_spline(inputs,
- unnormalized_widths,
- unnormalized_heights,
- unnormalized_derivatives,
- inverse=False,
- left=0., right=1., bottom=0., top=1.,
- min_bin_width=DEFAULT_MIN_BIN_WIDTH,
- min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
- min_derivative=DEFAULT_MIN_DERIVATIVE):
- if torch.min(inputs) < left or torch.max(inputs) > right:
- raise ValueError('Input to a transform is not within its domain')
-
- num_bins = unnormalized_widths.shape[-1]
-
- if min_bin_width * num_bins > 1.0:
- raise ValueError('Minimal bin width too large for the number of bins')
- if min_bin_height * num_bins > 1.0:
- raise ValueError('Minimal bin height too large for the number of bins')
-
- widths = F.softmax(unnormalized_widths, dim=-1)
- widths = min_bin_width + (1 - min_bin_width * num_bins) * widths
- cumwidths = torch.cumsum(widths, dim=-1)
- cumwidths = F.pad(cumwidths, pad=(1, 0), mode='constant', value=0.0)
- cumwidths = (right - left) * cumwidths + left
- cumwidths[..., 0] = left
- cumwidths[..., -1] = right
- widths = cumwidths[..., 1:] - cumwidths[..., :-1]
-
- derivatives = min_derivative + F.softplus(unnormalized_derivatives)
-
- heights = F.softmax(unnormalized_heights, dim=-1)
- heights = min_bin_height + (1 - min_bin_height * num_bins) * heights
- cumheights = torch.cumsum(heights, dim=-1)
- cumheights = F.pad(cumheights, pad=(1, 0), mode='constant', value=0.0)
- cumheights = (top - bottom) * cumheights + bottom
- cumheights[..., 0] = bottom
- cumheights[..., -1] = top
- heights = cumheights[..., 1:] - cumheights[..., :-1]
-
- if inverse:
- bin_idx = searchsorted(cumheights, inputs)[..., None]
- else:
- bin_idx = searchsorted(cumwidths, inputs)[..., None]
-
- input_cumwidths = cumwidths.gather(-1, bin_idx)[..., 0]
- input_bin_widths = widths.gather(-1, bin_idx)[..., 0]
-
- input_cumheights = cumheights.gather(-1, bin_idx)[..., 0]
- delta = heights / widths
- input_delta = delta.gather(-1, bin_idx)[..., 0]
-
- input_derivatives = derivatives.gather(-1, bin_idx)[..., 0]
- input_derivatives_plus_one = derivatives[..., 1:].gather(-1, bin_idx)[..., 0]
-
- input_heights = heights.gather(-1, bin_idx)[..., 0]
-
- if inverse:
- a = (((inputs - input_cumheights) * (input_derivatives
- + input_derivatives_plus_one
- - 2 * input_delta)
- + input_heights * (input_delta - input_derivatives)))
- b = (input_heights * input_derivatives
- - (inputs - input_cumheights) * (input_derivatives
- + input_derivatives_plus_one
- - 2 * input_delta))
- c = - input_delta * (inputs - input_cumheights)
-
- discriminant = b.pow(2) - 4 * a * c
- assert (discriminant >= 0).all()
-
- root = (2 * c) / (-b - torch.sqrt(discriminant))
- outputs = root * input_bin_widths + input_cumwidths
-
- theta_one_minus_theta = root * (1 - root)
- denominator = input_delta + ((input_derivatives + input_derivatives_plus_one - 2 * input_delta)
- * theta_one_minus_theta)
- derivative_numerator = input_delta.pow(2) * (input_derivatives_plus_one * root.pow(2)
- + 2 * input_delta * theta_one_minus_theta
- + input_derivatives * (1 - root).pow(2))
- logabsdet = torch.log(derivative_numerator) - 2 * torch.log(denominator)
-
- return outputs, -logabsdet
- else:
- theta = (inputs - input_cumwidths) / input_bin_widths
- theta_one_minus_theta = theta * (1 - theta)
-
- numerator = input_heights * (input_delta * theta.pow(2)
- + input_derivatives * theta_one_minus_theta)
- denominator = input_delta + ((input_derivatives + input_derivatives_plus_one - 2 * input_delta)
- * theta_one_minus_theta)
- outputs = input_cumheights + numerator / denominator
-
- derivative_numerator = input_delta.pow(2) * (input_derivatives_plus_one * theta.pow(2)
- + 2 * input_delta * theta_one_minus_theta
- + input_derivatives * (1 - theta).pow(2))
- logabsdet = torch.log(derivative_numerator) - 2 * torch.log(denominator)
-
- return outputs, logabsdet
diff --git a/spaces/allknowingroger/Image-Models-Test96/app.py b/spaces/allknowingroger/Image-Models-Test96/app.py
deleted file mode 100644
index 2d1754152087dab970148115f78f9ef9256bb20e..0000000000000000000000000000000000000000
--- a/spaces/allknowingroger/Image-Models-Test96/app.py
+++ /dev/null
@@ -1,144 +0,0 @@
-import gradio as gr
-# import os
-# import sys
-# from pathlib import Path
-import time
-
-models =[
- "Jbddai/lora-trained-xl-colab_potatohead",
- "GodSpeed15/my-pet-dog",
- "MakAttack/653bbca65b1b03cb7810faff",
- "LinoyTsaban/lora-trained-xl-colab-cam-0.0001-1000-4-text-encoder",
- "Jbddai/lora-trained-xl-colab_gieskanne",
- "craigdsouza/my-uig-racecar",
- "MakAttack/653cc69ec6b4bef9fcd3f9c9",
- "kycocotree/lora-trained-xl",
- "ThanhMai/lora-trained-xl-colab",
-]
-
-
-model_functions = {}
-model_idx = 1
-for model_path in models:
- try:
- model_functions[model_idx] = gr.Interface.load(f"models/{model_path}", live=False, preprocess=True, postprocess=False)
- except Exception as error:
- def the_fn(txt):
- return None
- model_functions[model_idx] = gr.Interface(fn=the_fn, inputs=["text"], outputs=["image"])
- model_idx+=1
-
-
-def send_it_idx(idx):
- def send_it_fn(prompt):
- output = (model_functions.get(str(idx)) or model_functions.get(str(1)))(prompt)
- return output
- return send_it_fn
-
-def get_prompts(prompt_text):
- return prompt_text
-
-def clear_it(val):
- if int(val) != 0:
- val = 0
- else:
- val = 0
- pass
- return val
-
-def all_task_end(cnt,t_stamp):
- to = t_stamp + 60
- et = time.time()
- if et > to and t_stamp != 0:
- d = gr.update(value=0)
- tog = gr.update(value=1)
- #print(f'to: {to} et: {et}')
- else:
- if cnt != 0:
- d = gr.update(value=et)
- else:
- d = gr.update(value=0)
- tog = gr.update(value=0)
- #print (f'passing: to: {to} et: {et}')
- pass
- return d, tog
-
-def all_task_start():
- print("\n\n\n\n\n\n\n")
- t = time.gmtime()
- t_stamp = time.time()
- current_time = time.strftime("%H:%M:%S", t)
- return gr.update(value=t_stamp), gr.update(value=t_stamp), gr.update(value=0)
-
-def clear_fn():
- nn = len(models)
- return tuple([None, *[None for _ in range(nn)]])
-
-
-
-with gr.Blocks(title="SD Models") as my_interface:
- with gr.Column(scale=12):
- # with gr.Row():
- # gr.Markdown("""- Primary prompt: 你想画的内容(英文单词，如 a cat, 加英文逗号效果更好；点 Improve 按钮进行完善)\n- Real prompt: 完善后的提示词，出现后再点右边的 Run 按钮开始运行""")
- with gr.Row():
- with gr.Row(scale=6):
- primary_prompt=gr.Textbox(label="Prompt", value="")
- # real_prompt=gr.Textbox(label="Real prompt")
- with gr.Row(scale=6):
- # improve_prompts_btn=gr.Button("Improve")
- with gr.Row():
- run=gr.Button("Run",variant="primary")
- clear_btn=gr.Button("Clear")
- with gr.Row():
- sd_outputs = {}
- model_idx = 1
- for model_path in models:
- with gr.Column(scale=3, min_width=320):
- with gr.Box():
- sd_outputs[model_idx] = gr.Image(label=model_path)
- pass
- model_idx += 1
- pass
- pass
-
- with gr.Row(visible=False):
- start_box=gr.Number(interactive=False)
- end_box=gr.Number(interactive=False)
- tog_box=gr.Textbox(value=0,interactive=False)
-
- start_box.change(
- all_task_end,
- [start_box, end_box],
- [start_box, tog_box],
- every=1,
- show_progress=False)
-
- primary_prompt.submit(all_task_start, None, [start_box, end_box, tog_box])
- run.click(all_task_start, None, [start_box, end_box, tog_box])
- runs_dict = {}
- model_idx = 1
- for model_path in models:
- runs_dict[model_idx] = run.click(model_functions[model_idx], inputs=[primary_prompt], outputs=[sd_outputs[model_idx]])
- model_idx += 1
- pass
- pass
-
- # improve_prompts_btn_clicked=improve_prompts_btn.click(
- # get_prompts,
- # inputs=[primary_prompt],
- # outputs=[primary_prompt],
- # cancels=list(runs_dict.values()))
- clear_btn.click(
- clear_fn,
- None,
- [primary_prompt, *list(sd_outputs.values())],
- cancels=[*list(runs_dict.values())])
- tog_box.change(
- clear_it,
- tog_box,
- tog_box,
- cancels=[*list(runs_dict.values())])
-
-my_interface.queue(concurrency_count=600, status_update_rate=1)
-my_interface.launch(inline=True, show_api=False)
-
\ No newline at end of file
diff --git a/spaces/andresgtn/sidewalk-semantic-segmentation/README.md b/spaces/andresgtn/sidewalk-semantic-segmentation/README.md
deleted file mode 100644
index 2700d6e4f163cab1543e6ffb799bca9f99e3d046..0000000000000000000000000000000000000000
--- a/spaces/andresgtn/sidewalk-semantic-segmentation/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Sidewalk Semantic Segmentation
-emoji: 🌍
-colorFrom: green
-colorTo: pink
-sdk: gradio
-sdk_version: 3.4
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/aodianyun/panoptic-segment-anything/segment_anything/setup.py b/spaces/aodianyun/panoptic-segment-anything/segment_anything/setup.py
deleted file mode 100644
index 2c0986317eb576a14ec774205c88fdee3cc6c0b3..0000000000000000000000000000000000000000
--- a/spaces/aodianyun/panoptic-segment-anything/segment_anything/setup.py
+++ /dev/null
@@ -1,18 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-from setuptools import find_packages, setup
-
-setup(
- name="segment_anything",
- version="1.0",
- install_requires=[],
- packages=find_packages(exclude="notebooks"),
- extras_require={
- "all": ["matplotlib", "pycocotools", "opencv-python", "onnx", "onnxruntime"],
- "dev": ["flake8", "isort", "black", "mypy"],
- },
-)
diff --git a/spaces/arsalagrey/audio-classification-vue/index.js b/spaces/arsalagrey/audio-classification-vue/index.js
deleted file mode 100644
index 6f8537e805a0397fd139cd3926fd42d19898eb77..0000000000000000000000000000000000000000
--- a/spaces/arsalagrey/audio-classification-vue/index.js
+++ /dev/null
@@ -1,81 +0,0 @@
-const { createApp, ref, onMounted, computed, watch } = Vue;
-import { HfInference } from "https://cdn.skypack.dev/@huggingface/inference@latest";
-
-const app = createApp({
- setup() {
- const token = ref(localStorage.getItem("token") || "");
- const models = ref(["MIT/ast-finetuned-audioset-10-10-0.4593"]);
- const selectedAudio = ref("airplane-landing.mp3");
- const selectedModel = ref("");
- const loading = ref(false);
- const didErrorOccur = ref(false)
- const audioFiles = ref(['airplane-landing.mp3',
- 'alien-spaceship.mp3',
- 'hard_shoes.mp3',
- 'labrador-barking.mp3',
- 'old-car-engine.mp3',
- 'tolling-bell.mp3']);
- const classificationLabels = ref([])
-
-
- const statusMessage = computed(() => {
- if (loading.value) return "Loading..."
- return "Ready"
- })
-
- const run = async () => {
- reset()
- loading.value = true;
- try {
- const hf = new HfInference(token.value);
- const audioData = await (await fetch(`sounds/${selectedAudio.value}`)).arrayBuffer()
- const result = await hf.audioClassification({
- data: audioData,
- model: selectedModel.value
- });
- console.log(result)
- classificationLabels.value = result
- loading.value = false;
- } catch (e) {
- console.error(e);
- loading.value = false;
- didErrorOccur.value = true
- }
- };
- const reset = () => {
- didErrorOccur.value = false
- loading.value = false
- classificationLabels.value = []
- }
-
- watch(selectedAudio, () => {
- reset()
- })
-
- watch(selectedModel, () => {
- reset()
- })
-
- onMounted(async () => {
- const localStorageToken = localStorage.getItem("token")
- if (localStorageToken) {
- token.value = localStorageToken;
- }
- selectedModel.value = models.value[0]
- });
-
- return {
- token,
- run,
- audioFiles,
- selectedAudio,
- models,
- selectedModel,
- loading,
- statusMessage,
- classificationLabels
- };
- },
-});
-
-app.mount("#app");
diff --git a/spaces/artificialguybr/video-dubbing/TTS/TTS/tts/configs/bark_config.py b/spaces/artificialguybr/video-dubbing/TTS/TTS/tts/configs/bark_config.py
deleted file mode 100644
index 4d1cd1374afe8d5f0b9e87ed81db25d7e4032af9..0000000000000000000000000000000000000000
--- a/spaces/artificialguybr/video-dubbing/TTS/TTS/tts/configs/bark_config.py
+++ /dev/null
@@ -1,105 +0,0 @@
-import os
-from dataclasses import dataclass, field
-from typing import Dict
-
-from TTS.tts.configs.shared_configs import BaseTTSConfig
-from TTS.tts.layers.bark.model import GPTConfig
-from TTS.tts.layers.bark.model_fine import FineGPTConfig
-from TTS.tts.models.bark import BarkAudioConfig
-from TTS.utils.generic_utils import get_user_data_dir
-
-
-@dataclass
-class BarkConfig(BaseTTSConfig):
- """Bark TTS configuration
-
- Args:
- model (str): model name that registers the model.
- audio (BarkAudioConfig): audio configuration. Defaults to BarkAudioConfig().
- num_chars (int): number of characters in the alphabet. Defaults to 0.
- semantic_config (GPTConfig): semantic configuration. Defaults to GPTConfig().
- fine_config (FineGPTConfig): fine configuration. Defaults to FineGPTConfig().
- coarse_config (GPTConfig): coarse configuration. Defaults to GPTConfig().
- CONTEXT_WINDOW_SIZE (int): GPT context window size. Defaults to 1024.
- SEMANTIC_RATE_HZ (float): semantic tokens rate in Hz. Defaults to 49.9.
- SEMANTIC_VOCAB_SIZE (int): semantic vocabulary size. Defaults to 10_000.
- CODEBOOK_SIZE (int): encodec codebook size. Defaults to 1024.
- N_COARSE_CODEBOOKS (int): number of coarse codebooks. Defaults to 2.
- N_FINE_CODEBOOKS (int): number of fine codebooks. Defaults to 8.
- COARSE_RATE_HZ (int): coarse tokens rate in Hz. Defaults to 75.
- SAMPLE_RATE (int): sample rate. Defaults to 24_000.
- USE_SMALLER_MODELS (bool): use smaller models. Defaults to False.
- TEXT_ENCODING_OFFSET (int): text encoding offset. Defaults to 10_048.
- SEMANTIC_PAD_TOKEN (int): semantic pad token. Defaults to 10_000.
- TEXT_PAD_TOKEN ([type]): text pad token. Defaults to 10_048.
- TEXT_EOS_TOKEN ([type]): text end of sentence token. Defaults to 10_049.
- TEXT_SOS_TOKEN ([type]): text start of sentence token. Defaults to 10_050.
- SEMANTIC_INFER_TOKEN (int): semantic infer token. Defaults to 10_051.
- COARSE_SEMANTIC_PAD_TOKEN (int): coarse semantic pad token. Defaults to 12_048.
- COARSE_INFER_TOKEN (int): coarse infer token. Defaults to 12_050.
- REMOTE_BASE_URL ([type]): remote base url. Defaults to "https://huggingface.co/erogol/bark/tree".
- REMOTE_MODEL_PATHS (Dict): remote model paths. Defaults to None.
- LOCAL_MODEL_PATHS (Dict): local model paths. Defaults to None.
- SMALL_REMOTE_MODEL_PATHS (Dict): small remote model paths. Defaults to None.
- CACHE_DIR (str): local cache directory. Defaults to get_user_data_dir().
- DEF_SPEAKER_DIR (str): default speaker directory to stoke speaker values for voice cloning. Defaults to get_user_data_dir().
- """
-
- model: str = "bark"
- audio: BarkAudioConfig = field(default_factory=BarkAudioConfig)
- num_chars: int = 0
- semantic_config: GPTConfig = field(default_factory=GPTConfig)
- fine_config: FineGPTConfig = field(default_factory=FineGPTConfig)
- coarse_config: GPTConfig = field(default_factory=GPTConfig)
- CONTEXT_WINDOW_SIZE: int = 1024
- SEMANTIC_RATE_HZ: float = 49.9
- SEMANTIC_VOCAB_SIZE: int = 10_000
- CODEBOOK_SIZE: int = 1024
- N_COARSE_CODEBOOKS: int = 2
- N_FINE_CODEBOOKS: int = 8
- COARSE_RATE_HZ: int = 75
- SAMPLE_RATE: int = 24_000
- USE_SMALLER_MODELS: bool = False
-
- TEXT_ENCODING_OFFSET: int = 10_048
- SEMANTIC_PAD_TOKEN: int = 10_000
- TEXT_PAD_TOKEN: int = 129_595
- SEMANTIC_INFER_TOKEN: int = 129_599
- COARSE_SEMANTIC_PAD_TOKEN: int = 12_048
- COARSE_INFER_TOKEN: int = 12_050
-
- REMOTE_BASE_URL = "https://huggingface.co/erogol/bark/tree/main/"
- REMOTE_MODEL_PATHS: Dict = None
- LOCAL_MODEL_PATHS: Dict = None
- SMALL_REMOTE_MODEL_PATHS: Dict = None
- CACHE_DIR: str = str(get_user_data_dir("tts/suno/bark_v0"))
- DEF_SPEAKER_DIR: str = str(get_user_data_dir("tts/bark_v0/speakers"))
-
- def __post_init__(self):
- self.REMOTE_MODEL_PATHS = {
- "text": {
- "path": os.path.join(self.REMOTE_BASE_URL, "text_2.pt"),
- "checksum": "54afa89d65e318d4f5f80e8e8799026a",
- },
- "coarse": {
- "path": os.path.join(self.REMOTE_BASE_URL, "coarse_2.pt"),
- "checksum": "8a98094e5e3a255a5c9c0ab7efe8fd28",
- },
- "fine": {
- "path": os.path.join(self.REMOTE_BASE_URL, "fine_2.pt"),
- "checksum": "59d184ed44e3650774a2f0503a48a97b",
- },
- }
- self.LOCAL_MODEL_PATHS = {
- "text": os.path.join(self.CACHE_DIR, "text_2.pt"),
- "coarse": os.path.join(self.CACHE_DIR, "coarse_2.pt"),
- "fine": os.path.join(self.CACHE_DIR, "fine_2.pt"),
- "hubert_tokenizer": os.path.join(self.CACHE_DIR, "tokenizer.pth"),
- "hubert": os.path.join(self.CACHE_DIR, "hubert.pt"),
- }
- self.SMALL_REMOTE_MODEL_PATHS = {
- "text": {"path": os.path.join(self.REMOTE_BASE_URL, "text.pt")},
- "coarse": {"path": os.path.join(self.REMOTE_BASE_URL, "coarse.pt")},
- "fine": {"path": os.path.join(self.REMOTE_BASE_URL, "fine.pt")},
- }
- self.sample_rate = self.SAMPLE_RATE # pylint: disable=attribute-defined-outside-init
diff --git a/spaces/artificialguybr/video-dubbing/TTS/TTS/tts/layers/generic/res_conv_bn.py b/spaces/artificialguybr/video-dubbing/TTS/TTS/tts/layers/generic/res_conv_bn.py
deleted file mode 100644
index 4beda291aa15398024b5b16cd6bf12b88898a0a9..0000000000000000000000000000000000000000
--- a/spaces/artificialguybr/video-dubbing/TTS/TTS/tts/layers/generic/res_conv_bn.py
+++ /dev/null
@@ -1,127 +0,0 @@
-from torch import nn
-
-
-class ZeroTemporalPad(nn.Module):
- """Pad sequences to equal lentgh in the temporal dimension"""
-
- def __init__(self, kernel_size, dilation):
- super().__init__()
- total_pad = dilation * (kernel_size - 1)
- begin = total_pad // 2
- end = total_pad - begin
- self.pad_layer = nn.ZeroPad2d((0, 0, begin, end))
-
- def forward(self, x):
- return self.pad_layer(x)
-
-
-class Conv1dBN(nn.Module):
- """1d convolutional with batch norm.
- conv1d -> relu -> BN blocks.
-
- Note:
- Batch normalization is applied after ReLU regarding the original implementation.
-
- Args:
- in_channels (int): number of input channels.
- out_channels (int): number of output channels.
- kernel_size (int): kernel size for convolutional filters.
- dilation (int): dilation for convolution layers.
- """
-
- def __init__(self, in_channels, out_channels, kernel_size, dilation):
- super().__init__()
- padding = dilation * (kernel_size - 1)
- pad_s = padding // 2
- pad_e = padding - pad_s
- self.conv1d = nn.Conv1d(in_channels, out_channels, kernel_size, dilation=dilation)
- self.pad = nn.ZeroPad2d((pad_s, pad_e, 0, 0)) # uneven left and right padding
- self.norm = nn.BatchNorm1d(out_channels)
-
- def forward(self, x):
- o = self.conv1d(x)
- o = self.pad(o)
- o = nn.functional.relu(o)
- o = self.norm(o)
- return o
-
-
-class Conv1dBNBlock(nn.Module):
- """1d convolutional block with batch norm. It is a set of conv1d -> relu -> BN blocks.
-
- Args:
- in_channels (int): number of input channels.
- out_channels (int): number of output channels.
- hidden_channels (int): number of inner convolution channels.
- kernel_size (int): kernel size for convolutional filters.
- dilation (int): dilation for convolution layers.
- num_conv_blocks (int, optional): number of convolutional blocks. Defaults to 2.
- """
-
- def __init__(self, in_channels, out_channels, hidden_channels, kernel_size, dilation, num_conv_blocks=2):
- super().__init__()
- self.conv_bn_blocks = []
- for idx in range(num_conv_blocks):
- layer = Conv1dBN(
- in_channels if idx == 0 else hidden_channels,
- out_channels if idx == (num_conv_blocks - 1) else hidden_channels,
- kernel_size,
- dilation,
- )
- self.conv_bn_blocks.append(layer)
- self.conv_bn_blocks = nn.Sequential(*self.conv_bn_blocks)
-
- def forward(self, x):
- """
- Shapes:
- x: (B, D, T)
- """
- return self.conv_bn_blocks(x)
-
-
-class ResidualConv1dBNBlock(nn.Module):
- """Residual Convolutional Blocks with BN
- Each block has 'num_conv_block' conv layers and 'num_res_blocks' such blocks are connected
- with residual connections.
-
- conv_block = (conv1d -> relu -> bn) x 'num_conv_blocks'
- residuak_conv_block = (x -> conv_block -> + ->) x 'num_res_blocks'
- ' - - - - - - - - - ^
- Args:
- in_channels (int): number of input channels.
- out_channels (int): number of output channels.
- hidden_channels (int): number of inner convolution channels.
- kernel_size (int): kernel size for convolutional filters.
- dilations (list): dilations for each convolution layer.
- num_res_blocks (int, optional): number of residual blocks. Defaults to 13.
- num_conv_blocks (int, optional): number of convolutional blocks in each residual block. Defaults to 2.
- """
-
- def __init__(
- self, in_channels, out_channels, hidden_channels, kernel_size, dilations, num_res_blocks=13, num_conv_blocks=2
- ):
- super().__init__()
- assert len(dilations) == num_res_blocks
- self.res_blocks = nn.ModuleList()
- for idx, dilation in enumerate(dilations):
- block = Conv1dBNBlock(
- in_channels if idx == 0 else hidden_channels,
- out_channels if (idx + 1) == len(dilations) else hidden_channels,
- hidden_channels,
- kernel_size,
- dilation,
- num_conv_blocks,
- )
- self.res_blocks.append(block)
-
- def forward(self, x, x_mask=None):
- if x_mask is None:
- x_mask = 1.0
- o = x * x_mask
- for block in self.res_blocks:
- res = o
- o = block(o)
- o = o + res
- if x_mask is not None:
- o = o * x_mask
- return o
diff --git a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/Crypto/Cipher/_mode_cbc.py b/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/Crypto/Cipher/_mode_cbc.py
deleted file mode 100644
index 79c871ac79f7d6f096fcd77269781e3a6a2a9fb5..0000000000000000000000000000000000000000
--- a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/Crypto/Cipher/_mode_cbc.py
+++ /dev/null
@@ -1,293 +0,0 @@
-# ===================================================================
-#
-# Copyright (c) 2014, Legrandin
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-#
-# 1. Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-# 2. Redistributions in binary form must reproduce the above copyright
-# notice, this list of conditions and the following disclaimer in
-# the documentation and/or other materials provided with the
-# distribution.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-# POSSIBILITY OF SUCH DAMAGE.
-# ===================================================================
-
-"""
-Ciphertext Block Chaining (CBC) mode.
-"""
-
-__all__ = ['CbcMode']
-
-from Crypto.Util.py3compat import _copy_bytes
-from Crypto.Util._raw_api import (load_pycryptodome_raw_lib, VoidPointer,
- create_string_buffer, get_raw_buffer,
- SmartPointer, c_size_t, c_uint8_ptr,
- is_writeable_buffer)
-
-from Crypto.Random import get_random_bytes
-
-raw_cbc_lib = load_pycryptodome_raw_lib("Crypto.Cipher._raw_cbc", """
- int CBC_start_operation(void *cipher,
- const uint8_t iv[],
- size_t iv_len,
- void **pResult);
- int CBC_encrypt(void *cbcState,
- const uint8_t *in,
- uint8_t *out,
- size_t data_len);
- int CBC_decrypt(void *cbcState,
- const uint8_t *in,
- uint8_t *out,
- size_t data_len);
- int CBC_stop_operation(void *state);
- """
- )
-
-
-class CbcMode(object):
- """*Cipher-Block Chaining (CBC)*.
-
- Each of the ciphertext blocks depends on the current
- and all previous plaintext blocks.
-
- An Initialization Vector (*IV*) is required.
-
- See `NIST SP800-38A`_ , Section 6.2 .
-
- .. _`NIST SP800-38A` : http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
-
- :undocumented: __init__
- """
-
- def __init__(self, block_cipher, iv):
- """Create a new block cipher, configured in CBC mode.
-
- :Parameters:
- block_cipher : C pointer
- A smart pointer to the low-level block cipher instance.
-
- iv : bytes/bytearray/memoryview
- The initialization vector to use for encryption or decryption.
- It is as long as the cipher block.
-
- **The IV must be unpredictable**. Ideally it is picked randomly.
-
- Reusing the *IV* for encryptions performed with the same key
- compromises confidentiality.
- """
-
- self._state = VoidPointer()
- result = raw_cbc_lib.CBC_start_operation(block_cipher.get(),
- c_uint8_ptr(iv),
- c_size_t(len(iv)),
- self._state.address_of())
- if result:
- raise ValueError("Error %d while instantiating the CBC mode"
- % result)
-
- # Ensure that object disposal of this Python object will (eventually)
- # free the memory allocated by the raw library for the cipher mode
- self._state = SmartPointer(self._state.get(),
- raw_cbc_lib.CBC_stop_operation)
-
- # Memory allocated for the underlying block cipher is now owed
- # by the cipher mode
- block_cipher.release()
-
- self.block_size = len(iv)
- """The block size of the underlying cipher, in bytes."""
-
- self.iv = _copy_bytes(None, None, iv)
- """The Initialization Vector originally used to create the object.
- The value does not change."""
-
- self.IV = self.iv
- """Alias for `iv`"""
-
- self._next = [ self.encrypt, self.decrypt ]
-
- def encrypt(self, plaintext, output=None):
- """Encrypt data with the key and the parameters set at initialization.
-
- A cipher object is stateful: once you have encrypted a message
- you cannot encrypt (or decrypt) another message using the same
- object.
-
- The data to encrypt can be broken up in two or
- more pieces and `encrypt` can be called multiple times.
-
- That is, the statement:
-
- >>> c.encrypt(a) + c.encrypt(b)
-
- is equivalent to:
-
- >>> c.encrypt(a+b)
-
- That also means that you cannot reuse an object for encrypting
- or decrypting other data with the same key.
-
- This function does not add any padding to the plaintext.
-
- :Parameters:
- plaintext : bytes/bytearray/memoryview
- The piece of data to encrypt.
- Its lenght must be multiple of the cipher block size.
- :Keywords:
- output : bytearray/memoryview
- The location where the ciphertext must be written to.
- If ``None``, the ciphertext is returned.
- :Return:
- If ``output`` is ``None``, the ciphertext is returned as ``bytes``.
- Otherwise, ``None``.
- """
-
- if self.encrypt not in self._next:
- raise TypeError("encrypt() cannot be called after decrypt()")
- self._next = [ self.encrypt ]
-
- if output is None:
- ciphertext = create_string_buffer(len(plaintext))
- else:
- ciphertext = output
-
- if not is_writeable_buffer(output):
- raise TypeError("output must be a bytearray or a writeable memoryview")
-
- if len(plaintext) != len(output):
- raise ValueError("output must have the same length as the input"
- " (%d bytes)" % len(plaintext))
-
- result = raw_cbc_lib.CBC_encrypt(self._state.get(),
- c_uint8_ptr(plaintext),
- c_uint8_ptr(ciphertext),
- c_size_t(len(plaintext)))
- if result:
- if result == 3:
- raise ValueError("Data must be padded to %d byte boundary in CBC mode" % self.block_size)
- raise ValueError("Error %d while encrypting in CBC mode" % result)
-
- if output is None:
- return get_raw_buffer(ciphertext)
- else:
- return None
-
- def decrypt(self, ciphertext, output=None):
- """Decrypt data with the key and the parameters set at initialization.
-
- A cipher object is stateful: once you have decrypted a message
- you cannot decrypt (or encrypt) another message with the same
- object.
-
- The data to decrypt can be broken up in two or
- more pieces and `decrypt` can be called multiple times.
-
- That is, the statement:
-
- >>> c.decrypt(a) + c.decrypt(b)
-
- is equivalent to:
-
- >>> c.decrypt(a+b)
-
- This function does not remove any padding from the plaintext.
-
- :Parameters:
- ciphertext : bytes/bytearray/memoryview
- The piece of data to decrypt.
- Its length must be multiple of the cipher block size.
- :Keywords:
- output : bytearray/memoryview
- The location where the plaintext must be written to.
- If ``None``, the plaintext is returned.
- :Return:
- If ``output`` is ``None``, the plaintext is returned as ``bytes``.
- Otherwise, ``None``.
- """
-
- if self.decrypt not in self._next:
- raise TypeError("decrypt() cannot be called after encrypt()")
- self._next = [ self.decrypt ]
-
- if output is None:
- plaintext = create_string_buffer(len(ciphertext))
- else:
- plaintext = output
-
- if not is_writeable_buffer(output):
- raise TypeError("output must be a bytearray or a writeable memoryview")
-
- if len(ciphertext) != len(output):
- raise ValueError("output must have the same length as the input"
- " (%d bytes)" % len(plaintext))
-
- result = raw_cbc_lib.CBC_decrypt(self._state.get(),
- c_uint8_ptr(ciphertext),
- c_uint8_ptr(plaintext),
- c_size_t(len(ciphertext)))
- if result:
- if result == 3:
- raise ValueError("Data must be padded to %d byte boundary in CBC mode" % self.block_size)
- raise ValueError("Error %d while decrypting in CBC mode" % result)
-
- if output is None:
- return get_raw_buffer(plaintext)
- else:
- return None
-
-
-def _create_cbc_cipher(factory, **kwargs):
- """Instantiate a cipher object that performs CBC encryption/decryption.
-
- :Parameters:
- factory : module
- The underlying block cipher, a module from ``Crypto.Cipher``.
-
- :Keywords:
- iv : bytes/bytearray/memoryview
- The IV to use for CBC.
-
- IV : bytes/bytearray/memoryview
- Alias for ``iv``.
-
- Any other keyword will be passed to the underlying block cipher.
- See the relevant documentation for details (at least ``key`` will need
- to be present).
- """
-
- cipher_state = factory._create_base_cipher(kwargs)
- iv = kwargs.pop("IV", None)
- IV = kwargs.pop("iv", None)
-
- if (None, None) == (iv, IV):
- iv = get_random_bytes(factory.block_size)
- if iv is not None:
- if IV is not None:
- raise TypeError("You must either use 'iv' or 'IV', not both")
- else:
- iv = IV
-
- if len(iv) != factory.block_size:
- raise ValueError("Incorrect IV length (it must be %d bytes long)" %
- factory.block_size)
-
- if kwargs:
- raise TypeError("Unknown parameters for CBC: %s" % str(kwargs))
-
- return CbcMode(cipher_state, iv)
diff --git a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/Cython/Compiler/Future.py b/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/Cython/Compiler/Future.py
deleted file mode 100644
index 848792e00bf21d57e7cb680ab5199123093ca96c..0000000000000000000000000000000000000000
--- a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/Cython/Compiler/Future.py
+++ /dev/null
@@ -1,15 +0,0 @@
-def _get_feature(name):
- import __future__
- # fall back to a unique fake object for earlier Python versions or Python 3
- return getattr(__future__, name, object())
-
-unicode_literals = _get_feature("unicode_literals")
-with_statement = _get_feature("with_statement") # dummy
-division = _get_feature("division")
-print_function = _get_feature("print_function")
-absolute_import = _get_feature("absolute_import")
-nested_scopes = _get_feature("nested_scopes") # dummy
-generators = _get_feature("generators") # dummy
-generator_stop = _get_feature("generator_stop")
-
-del _get_feature
diff --git a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/PIL/Image.py b/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/PIL/Image.py
deleted file mode 100644
index 7faf0c2481ba1832303757d578d62b8594332713..0000000000000000000000000000000000000000
--- a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/PIL/Image.py
+++ /dev/null
@@ -1,3760 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# the Image class wrapper
-#
-# partial release history:
-# 1995-09-09 fl Created
-# 1996-03-11 fl PIL release 0.0 (proof of concept)
-# 1996-04-30 fl PIL release 0.1b1
-# 1999-07-28 fl PIL release 1.0 final
-# 2000-06-07 fl PIL release 1.1
-# 2000-10-20 fl PIL release 1.1.1
-# 2001-05-07 fl PIL release 1.1.2
-# 2002-03-15 fl PIL release 1.1.3
-# 2003-05-10 fl PIL release 1.1.4
-# 2005-03-28 fl PIL release 1.1.5
-# 2006-12-02 fl PIL release 1.1.6
-# 2009-11-15 fl PIL release 1.1.7
-#
-# Copyright (c) 1997-2009 by Secret Labs AB. All rights reserved.
-# Copyright (c) 1995-2009 by Fredrik Lundh.
-#
-# See the README file for information on usage and redistribution.
-#
-
-import atexit
-import builtins
-import io
-import logging
-import math
-import os
-import re
-import struct
-import sys
-import tempfile
-import warnings
-from collections.abc import Callable, MutableMapping
-from enum import IntEnum
-from pathlib import Path
-
-try:
- import defusedxml.ElementTree as ElementTree
-except ImportError:
- ElementTree = None
-
-# VERSION was removed in Pillow 6.0.0.
-# PILLOW_VERSION was removed in Pillow 9.0.0.
-# Use __version__ instead.
-from . import ImageMode, TiffTags, UnidentifiedImageError, __version__, _plugins
-from ._binary import i32le, o32be, o32le
-from ._deprecate import deprecate
-from ._util import DeferredError, is_path
-
-
-def __getattr__(name):
- categories = {"NORMAL": 0, "SEQUENCE": 1, "CONTAINER": 2}
- if name in categories:
- deprecate("Image categories", 10, "is_animated", plural=True)
- return categories[name]
- elif name in ("NEAREST", "NONE"):
- deprecate(name, 10, "Resampling.NEAREST or Dither.NONE")
- return 0
- old_resampling = {
- "LINEAR": "BILINEAR",
- "CUBIC": "BICUBIC",
- "ANTIALIAS": "LANCZOS",
- }
- if name in old_resampling:
- deprecate(name, 10, f"Resampling.{old_resampling[name]}")
- return Resampling[old_resampling[name]]
- for enum in (Transpose, Transform, Resampling, Dither, Palette, Quantize):
- if name in enum.__members__:
- deprecate(name, 10, f"{enum.__name__}.{name}")
- return enum[name]
- raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
-
-
-logger = logging.getLogger(__name__)
-
-
-class DecompressionBombWarning(RuntimeWarning):
- pass
-
-
-class DecompressionBombError(Exception):
- pass
-
-
-# Limit to around a quarter gigabyte for a 24-bit (3 bpp) image
-MAX_IMAGE_PIXELS = int(1024 * 1024 * 1024 // 4 // 3)
-
-
-try:
- # If the _imaging C module is not present, Pillow will not load.
- # Note that other modules should not refer to _imaging directly;
- # import Image and use the Image.core variable instead.
- # Also note that Image.core is not a publicly documented interface,
- # and should be considered private and subject to change.
- from . import _imaging as core
-
- if __version__ != getattr(core, "PILLOW_VERSION", None):
- raise ImportError(
- "The _imaging extension was built for another version of Pillow or PIL:\n"
- f"Core version: {getattr(core, 'PILLOW_VERSION', None)}\n"
- f"Pillow version: {__version__}"
- )
-
-except ImportError as v:
- core = DeferredError(ImportError("The _imaging C module is not installed."))
- # Explanations for ways that we know we might have an import error
- if str(v).startswith("Module use of python"):
- # The _imaging C module is present, but not compiled for
- # the right version (windows only). Print a warning, if
- # possible.
- warnings.warn(
- "The _imaging extension was built for another version of Python.",
- RuntimeWarning,
- )
- elif str(v).startswith("The _imaging extension"):
- warnings.warn(str(v), RuntimeWarning)
- # Fail here anyway. Don't let people run with a mostly broken Pillow.
- # see docs/porting.rst
- raise
-
-
-# works everywhere, win for pypy, not cpython
-USE_CFFI_ACCESS = hasattr(sys, "pypy_version_info")
-try:
- import cffi
-except ImportError:
- cffi = None
-
-
-def isImageType(t):
- """
- Checks if an object is an image object.
-
- .. warning::
-
- This function is for internal use only.
-
- :param t: object to check if it's an image
- :returns: True if the object is an image
- """
- return hasattr(t, "im")
-
-
-#
-# Constants
-
-# transpose
-class Transpose(IntEnum):
- FLIP_LEFT_RIGHT = 0
- FLIP_TOP_BOTTOM = 1
- ROTATE_90 = 2
- ROTATE_180 = 3
- ROTATE_270 = 4
- TRANSPOSE = 5
- TRANSVERSE = 6
-
-
-# transforms (also defined in Imaging.h)
-class Transform(IntEnum):
- AFFINE = 0
- EXTENT = 1
- PERSPECTIVE = 2
- QUAD = 3
- MESH = 4
-
-
-# resampling filters (also defined in Imaging.h)
-class Resampling(IntEnum):
- NEAREST = 0
- BOX = 4
- BILINEAR = 2
- HAMMING = 5
- BICUBIC = 3
- LANCZOS = 1
-
-
-_filters_support = {
- Resampling.BOX: 0.5,
- Resampling.BILINEAR: 1.0,
- Resampling.HAMMING: 1.0,
- Resampling.BICUBIC: 2.0,
- Resampling.LANCZOS: 3.0,
-}
-
-
-# dithers
-class Dither(IntEnum):
- NONE = 0
- ORDERED = 1 # Not yet implemented
- RASTERIZE = 2 # Not yet implemented
- FLOYDSTEINBERG = 3 # default
-
-
-# palettes/quantizers
-class Palette(IntEnum):
- WEB = 0
- ADAPTIVE = 1
-
-
-class Quantize(IntEnum):
- MEDIANCUT = 0
- MAXCOVERAGE = 1
- FASTOCTREE = 2
- LIBIMAGEQUANT = 3
-
-
-if hasattr(core, "DEFAULT_STRATEGY"):
- DEFAULT_STRATEGY = core.DEFAULT_STRATEGY
- FILTERED = core.FILTERED
- HUFFMAN_ONLY = core.HUFFMAN_ONLY
- RLE = core.RLE
- FIXED = core.FIXED
-
-
-# --------------------------------------------------------------------
-# Registries
-
-ID = []
-OPEN = {}
-MIME = {}
-SAVE = {}
-SAVE_ALL = {}
-EXTENSION = {}
-DECODERS = {}
-ENCODERS = {}
-
-# --------------------------------------------------------------------
-# Modes
-
-_ENDIAN = "<" if sys.byteorder == "little" else ">"
-
-
-def _conv_type_shape(im):
- m = ImageMode.getmode(im.mode)
- shape = (im.height, im.width)
- extra = len(m.bands)
- if extra != 1:
- shape += (extra,)
- return shape, m.typestr
-
-
-MODES = ["1", "CMYK", "F", "HSV", "I", "L", "LAB", "P", "RGB", "RGBA", "RGBX", "YCbCr"]
-
-# raw modes that may be memory mapped. NOTE: if you change this, you
-# may have to modify the stride calculation in map.c too!
-_MAPMODES = ("L", "P", "RGBX", "RGBA", "CMYK", "I;16", "I;16L", "I;16B")
-
-
-def getmodebase(mode):
- """
- Gets the "base" mode for given mode. This function returns "L" for
- images that contain grayscale data, and "RGB" for images that
- contain color data.
-
- :param mode: Input mode.
- :returns: "L" or "RGB".
- :exception KeyError: If the input mode was not a standard mode.
- """
- return ImageMode.getmode(mode).basemode
-
-
-def getmodetype(mode):
- """
- Gets the storage type mode. Given a mode, this function returns a
- single-layer mode suitable for storing individual bands.
-
- :param mode: Input mode.
- :returns: "L", "I", or "F".
- :exception KeyError: If the input mode was not a standard mode.
- """
- return ImageMode.getmode(mode).basetype
-
-
-def getmodebandnames(mode):
- """
- Gets a list of individual band names. Given a mode, this function returns
- a tuple containing the names of individual bands (use
- :py:method:`~PIL.Image.getmodetype` to get the mode used to store each
- individual band.
-
- :param mode: Input mode.
- :returns: A tuple containing band names. The length of the tuple
- gives the number of bands in an image of the given mode.
- :exception KeyError: If the input mode was not a standard mode.
- """
- return ImageMode.getmode(mode).bands
-
-
-def getmodebands(mode):
- """
- Gets the number of individual bands for this mode.
-
- :param mode: Input mode.
- :returns: The number of bands in this mode.
- :exception KeyError: If the input mode was not a standard mode.
- """
- return len(ImageMode.getmode(mode).bands)
-
-
-# --------------------------------------------------------------------
-# Helpers
-
-_initialized = 0
-
-
-def preinit():
- """Explicitly load standard file format drivers."""
-
- global _initialized
- if _initialized >= 1:
- return
-
- try:
- from . import BmpImagePlugin
-
- assert BmpImagePlugin
- except ImportError:
- pass
- try:
- from . import GifImagePlugin
-
- assert GifImagePlugin
- except ImportError:
- pass
- try:
- from . import JpegImagePlugin
-
- assert JpegImagePlugin
- except ImportError:
- pass
- try:
- from . import PpmImagePlugin
-
- assert PpmImagePlugin
- except ImportError:
- pass
- try:
- from . import PngImagePlugin
-
- assert PngImagePlugin
- except ImportError:
- pass
- # try:
- # import TiffImagePlugin
- # assert TiffImagePlugin
- # except ImportError:
- # pass
-
- _initialized = 1
-
-
-def init():
- """
- Explicitly initializes the Python Imaging Library. This function
- loads all available file format drivers.
- """
-
- global _initialized
- if _initialized >= 2:
- return 0
-
- for plugin in _plugins:
- try:
- logger.debug("Importing %s", plugin)
- __import__(f"PIL.{plugin}", globals(), locals(), [])
- except ImportError as e:
- logger.debug("Image: failed to import %s: %s", plugin, e)
-
- if OPEN or SAVE:
- _initialized = 2
- return 1
-
-
-# --------------------------------------------------------------------
-# Codec factories (used by tobytes/frombytes and ImageFile.load)
-
-
-def _getdecoder(mode, decoder_name, args, extra=()):
-
- # tweak arguments
- if args is None:
- args = ()
- elif not isinstance(args, tuple):
- args = (args,)
-
- try:
- decoder = DECODERS[decoder_name]
- except KeyError:
- pass
- else:
- return decoder(mode, *args + extra)
-
- try:
- # get decoder
- decoder = getattr(core, decoder_name + "_decoder")
- except AttributeError as e:
- raise OSError(f"decoder {decoder_name} not available") from e
- return decoder(mode, *args + extra)
-
-
-def _getencoder(mode, encoder_name, args, extra=()):
-
- # tweak arguments
- if args is None:
- args = ()
- elif not isinstance(args, tuple):
- args = (args,)
-
- try:
- encoder = ENCODERS[encoder_name]
- except KeyError:
- pass
- else:
- return encoder(mode, *args + extra)
-
- try:
- # get encoder
- encoder = getattr(core, encoder_name + "_encoder")
- except AttributeError as e:
- raise OSError(f"encoder {encoder_name} not available") from e
- return encoder(mode, *args + extra)
-
-
-# --------------------------------------------------------------------
-# Simple expression analyzer
-
-
-def coerce_e(value):
- deprecate("coerce_e", 10)
- return value if isinstance(value, _E) else _E(1, value)
-
-
-# _E(scale, offset) represents the affine transformation scale * x + offset.
-# The "data" field is named for compatibility with the old implementation,
-# and should be renamed once coerce_e is removed.
-class _E:
- def __init__(self, scale, data):
- self.scale = scale
- self.data = data
-
- def __neg__(self):
- return _E(-self.scale, -self.data)
-
- def __add__(self, other):
- if isinstance(other, _E):
- return _E(self.scale + other.scale, self.data + other.data)
- return _E(self.scale, self.data + other)
-
- __radd__ = __add__
-
- def __sub__(self, other):
- return self + -other
-
- def __rsub__(self, other):
- return other + -self
-
- def __mul__(self, other):
- if isinstance(other, _E):
- return NotImplemented
- return _E(self.scale * other, self.data * other)
-
- __rmul__ = __mul__
-
- def __truediv__(self, other):
- if isinstance(other, _E):
- return NotImplemented
- return _E(self.scale / other, self.data / other)
-
-
-def _getscaleoffset(expr):
- a = expr(_E(1, 0))
- return (a.scale, a.data) if isinstance(a, _E) else (0, a)
-
-
-# --------------------------------------------------------------------
-# Implementation wrapper
-
-
-class Image:
- """
- This class represents an image object. To create
- :py:class:`~PIL.Image.Image` objects, use the appropriate factory
- functions. There's hardly ever any reason to call the Image constructor
- directly.
-
- * :py:func:`~PIL.Image.open`
- * :py:func:`~PIL.Image.new`
- * :py:func:`~PIL.Image.frombytes`
- """
-
- format = None
- format_description = None
- _close_exclusive_fp_after_loading = True
-
- def __init__(self):
- # FIXME: take "new" parameters / other image?
- # FIXME: turn mode and size into delegating properties?
- self.im = None
- self.mode = ""
- self._size = (0, 0)
- self.palette = None
- self.info = {}
- self._category = 0
- self.readonly = 0
- self.pyaccess = None
- self._exif = None
-
- def __getattr__(self, name):
- if name == "category":
- deprecate("Image categories", 10, "is_animated", plural=True)
- return self._category
- raise AttributeError(name)
-
- @property
- def width(self):
- return self.size[0]
-
- @property
- def height(self):
- return self.size[1]
-
- @property
- def size(self):
- return self._size
-
- def _new(self, im):
- new = Image()
- new.im = im
- new.mode = im.mode
- new._size = im.size
- if im.mode in ("P", "PA"):
- if self.palette:
- new.palette = self.palette.copy()
- else:
- from . import ImagePalette
-
- new.palette = ImagePalette.ImagePalette()
- new.info = self.info.copy()
- return new
-
- # Context manager support
- def __enter__(self):
- return self
-
- def __exit__(self, *args):
- if hasattr(self, "fp") and getattr(self, "_exclusive_fp", False):
- if getattr(self, "_fp", False):
- if self._fp != self.fp:
- self._fp.close()
- self._fp = DeferredError(ValueError("Operation on closed image"))
- if self.fp:
- self.fp.close()
- self.fp = None
-
- def close(self):
- """
- Closes the file pointer, if possible.
-
- This operation will destroy the image core and release its memory.
- The image data will be unusable afterward.
-
- This function is required to close images that have multiple frames or
- have not had their file read and closed by the
- :py:meth:`~PIL.Image.Image.load` method. See :ref:`file-handling` for
- more information.
- """
- try:
- if getattr(self, "_fp", False):
- if self._fp != self.fp:
- self._fp.close()
- self._fp = DeferredError(ValueError("Operation on closed image"))
- if self.fp:
- self.fp.close()
- self.fp = None
- except Exception as msg:
- logger.debug("Error closing: %s", msg)
-
- if getattr(self, "map", None):
- self.map = None
-
- # Instead of simply setting to None, we're setting up a
- # deferred error that will better explain that the core image
- # object is gone.
- self.im = DeferredError(ValueError("Operation on closed image"))
-
- def _copy(self):
- self.load()
- self.im = self.im.copy()
- self.pyaccess = None
- self.readonly = 0
-
- def _ensure_mutable(self):
- if self.readonly:
- self._copy()
- else:
- self.load()
-
- def _dump(self, file=None, format=None, **options):
- suffix = ""
- if format:
- suffix = "." + format
-
- if not file:
- f, filename = tempfile.mkstemp(suffix)
- os.close(f)
- else:
- filename = file
- if not filename.endswith(suffix):
- filename = filename + suffix
-
- self.load()
-
- if not format or format == "PPM":
- self.im.save_ppm(filename)
- else:
- self.save(filename, format, **options)
-
- return filename
-
- def __eq__(self, other):
- return (
- self.__class__ is other.__class__
- and self.mode == other.mode
- and self.size == other.size
- and self.info == other.info
- and self._category == other._category
- and self.getpalette() == other.getpalette()
- and self.tobytes() == other.tobytes()
- )
-
- def __repr__(self):
- return "<%s.%s image mode=%s size=%dx%d at 0x%X>" % (
- self.__class__.__module__,
- self.__class__.__name__,
- self.mode,
- self.size[0],
- self.size[1],
- id(self),
- )
-
- def _repr_pretty_(self, p, cycle):
- """IPython plain text display support"""
-
- # Same as __repr__ but without unpredictable id(self),
- # to keep Jupyter notebook `text/plain` output stable.
- p.text(
- "<%s.%s image mode=%s size=%dx%d>"
- % (
- self.__class__.__module__,
- self.__class__.__name__,
- self.mode,
- self.size[0],
- self.size[1],
- )
- )
-
- def _repr_png_(self):
- """iPython display hook support
-
- :returns: png version of the image as bytes
- """
- b = io.BytesIO()
- try:
- self.save(b, "PNG")
- except Exception as e:
- raise ValueError("Could not save to PNG for display") from e
- return b.getvalue()
-
- @property
- def __array_interface__(self):
- # numpy array interface support
- new = {}
- shape, typestr = _conv_type_shape(self)
- new["shape"] = shape
- new["typestr"] = typestr
- new["version"] = 3
- try:
- if self.mode == "1":
- # Binary images need to be extended from bits to bytes
- # See: https://github.com/python-pillow/Pillow/issues/350
- new["data"] = self.tobytes("raw", "L")
- else:
- new["data"] = self.tobytes()
- except Exception as e:
- if not isinstance(e, (MemoryError, RecursionError)):
- try:
- import numpy
- from packaging.version import parse as parse_version
- except ImportError:
- pass
- else:
- if parse_version(numpy.__version__) < parse_version("1.23"):
- warnings.warn(e)
- raise
- return new
-
- def __getstate__(self):
- return [self.info, self.mode, self.size, self.getpalette(), self.tobytes()]
-
- def __setstate__(self, state):
- Image.__init__(self)
- self.tile = []
- info, mode, size, palette, data = state
- self.info = info
- self.mode = mode
- self._size = size
- self.im = core.new(mode, size)
- if mode in ("L", "LA", "P", "PA") and palette:
- self.putpalette(palette)
- self.frombytes(data)
-
- def tobytes(self, encoder_name="raw", *args):
- """
- Return image as a bytes object.
-
- .. warning::
-
- This method returns the raw image data from the internal
- storage. For compressed image data (e.g. PNG, JPEG) use
- :meth:`~.save`, with a BytesIO parameter for in-memory
- data.
-
- :param encoder_name: What encoder to use. The default is to
- use the standard "raw" encoder.
-
- A list of C encoders can be seen under
- codecs section of the function array in
- :file:`_imaging.c`. Python encoders are
- registered within the relevant plugins.
- :param args: Extra arguments to the encoder.
- :returns: A :py:class:`bytes` object.
- """
-
- # may pass tuple instead of argument list
- if len(args) == 1 and isinstance(args[0], tuple):
- args = args[0]
-
- if encoder_name == "raw" and args == ():
- args = self.mode
-
- self.load()
-
- if self.width == 0 or self.height == 0:
- return b""
-
- # unpack data
- e = _getencoder(self.mode, encoder_name, args)
- e.setimage(self.im)
-
- bufsize = max(65536, self.size[0] * 4) # see RawEncode.c
-
- data = []
- while True:
- l, s, d = e.encode(bufsize)
- data.append(d)
- if s:
- break
- if s < 0:
- raise RuntimeError(f"encoder error {s} in tobytes")
-
- return b"".join(data)
-
- def tobitmap(self, name="image"):
- """
- Returns the image converted to an X11 bitmap.
-
- .. note:: This method only works for mode "1" images.
-
- :param name: The name prefix to use for the bitmap variables.
- :returns: A string containing an X11 bitmap.
- :raises ValueError: If the mode is not "1"
- """
-
- self.load()
- if self.mode != "1":
- raise ValueError("not a bitmap")
- data = self.tobytes("xbm")
- return b"".join(
- [
- f"#define {name}_width {self.size[0]}\n".encode("ascii"),
- f"#define {name}_height {self.size[1]}\n".encode("ascii"),
- f"static char {name}_bits[] = {{\n".encode("ascii"),
- data,
- b"};",
- ]
- )
-
- def frombytes(self, data, decoder_name="raw", *args):
- """
- Loads this image with pixel data from a bytes object.
-
- This method is similar to the :py:func:`~PIL.Image.frombytes` function,
- but loads data into this image instead of creating a new image object.
- """
-
- # may pass tuple instead of argument list
- if len(args) == 1 and isinstance(args[0], tuple):
- args = args[0]
-
- # default format
- if decoder_name == "raw" and args == ():
- args = self.mode
-
- # unpack data
- d = _getdecoder(self.mode, decoder_name, args)
- d.setimage(self.im)
- s = d.decode(data)
-
- if s[0] >= 0:
- raise ValueError("not enough image data")
- if s[1] != 0:
- raise ValueError("cannot decode image data")
-
- def load(self):
- """
- Allocates storage for the image and loads the pixel data. In
- normal cases, you don't need to call this method, since the
- Image class automatically loads an opened image when it is
- accessed for the first time.
-
- If the file associated with the image was opened by Pillow, then this
- method will close it. The exception to this is if the image has
- multiple frames, in which case the file will be left open for seek
- operations. See :ref:`file-handling` for more information.
-
- :returns: An image access object.
- :rtype: :ref:`PixelAccess` or :py:class:`PIL.PyAccess`
- """
- if self.im is not None and self.palette and self.palette.dirty:
- # realize palette
- mode, arr = self.palette.getdata()
- self.im.putpalette(mode, arr)
- self.palette.dirty = 0
- self.palette.rawmode = None
- if "transparency" in self.info and mode in ("LA", "PA"):
- if isinstance(self.info["transparency"], int):
- self.im.putpalettealpha(self.info["transparency"], 0)
- else:
- self.im.putpalettealphas(self.info["transparency"])
- self.palette.mode = "RGBA"
- else:
- palette_mode = "RGBA" if mode.startswith("RGBA") else "RGB"
- self.palette.mode = palette_mode
- self.palette.palette = self.im.getpalette(palette_mode, palette_mode)
-
- if self.im is not None:
- if cffi and USE_CFFI_ACCESS:
- if self.pyaccess:
- return self.pyaccess
- from . import PyAccess
-
- self.pyaccess = PyAccess.new(self, self.readonly)
- if self.pyaccess:
- return self.pyaccess
- return self.im.pixel_access(self.readonly)
-
- def verify(self):
- """
- Verifies the contents of a file. For data read from a file, this
- method attempts to determine if the file is broken, without
- actually decoding the image data. If this method finds any
- problems, it raises suitable exceptions. If you need to load
- the image after using this method, you must reopen the image
- file.
- """
- pass
-
- def convert(
- self, mode=None, matrix=None, dither=None, palette=Palette.WEB, colors=256
- ):
- """
- Returns a converted copy of this image. For the "P" mode, this
- method translates pixels through the palette. If mode is
- omitted, a mode is chosen so that all information in the image
- and the palette can be represented without a palette.
-
- The current version supports all possible conversions between
- "L", "RGB" and "CMYK". The ``matrix`` argument only supports "L"
- and "RGB".
-
- When translating a color image to greyscale (mode "L"),
- the library uses the ITU-R 601-2 luma transform::
-
- L = R * 299/1000 + G * 587/1000 + B * 114/1000
-
- The default method of converting a greyscale ("L") or "RGB"
- image into a bilevel (mode "1") image uses Floyd-Steinberg
- dither to approximate the original image luminosity levels. If
- dither is ``None``, all values larger than 127 are set to 255 (white),
- all other values to 0 (black). To use other thresholds, use the
- :py:meth:`~PIL.Image.Image.point` method.
-
- When converting from "RGBA" to "P" without a ``matrix`` argument,
- this passes the operation to :py:meth:`~PIL.Image.Image.quantize`,
- and ``dither`` and ``palette`` are ignored.
-
- When converting from "PA", if an "RGBA" palette is present, the alpha
- channel from the image will be used instead of the values from the palette.
-
- :param mode: The requested mode. See: :ref:`concept-modes`.
- :param matrix: An optional conversion matrix. If given, this
- should be 4- or 12-tuple containing floating point values.
- :param dither: Dithering method, used when converting from
- mode "RGB" to "P" or from "RGB" or "L" to "1".
- Available methods are :data:`Dither.NONE` or :data:`Dither.FLOYDSTEINBERG`
- (default). Note that this is not used when ``matrix`` is supplied.
- :param palette: Palette to use when converting from mode "RGB"
- to "P". Available palettes are :data:`Palette.WEB` or
- :data:`Palette.ADAPTIVE`.
- :param colors: Number of colors to use for the :data:`Palette.ADAPTIVE`
- palette. Defaults to 256.
- :rtype: :py:class:`~PIL.Image.Image`
- :returns: An :py:class:`~PIL.Image.Image` object.
- """
-
- self.load()
-
- has_transparency = self.info.get("transparency") is not None
- if not mode and self.mode == "P":
- # determine default mode
- if self.palette:
- mode = self.palette.mode
- else:
- mode = "RGB"
- if mode == "RGB" and has_transparency:
- mode = "RGBA"
- if not mode or (mode == self.mode and not matrix):
- return self.copy()
-
- if matrix:
- # matrix conversion
- if mode not in ("L", "RGB"):
- raise ValueError("illegal conversion")
- im = self.im.convert_matrix(mode, matrix)
- new = self._new(im)
- if has_transparency and self.im.bands == 3:
- transparency = new.info["transparency"]
-
- def convert_transparency(m, v):
- v = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3] * 0.5
- return max(0, min(255, int(v)))
-
- if mode == "L":
- transparency = convert_transparency(matrix, transparency)
- elif len(mode) == 3:
- transparency = tuple(
- convert_transparency(matrix[i * 4 : i * 4 + 4], transparency)
- for i in range(0, len(transparency))
- )
- new.info["transparency"] = transparency
- return new
-
- if mode == "P" and self.mode == "RGBA":
- return self.quantize(colors)
-
- trns = None
- delete_trns = False
- # transparency handling
- if has_transparency:
- if (self.mode in ("1", "L", "I") and mode in ("LA", "RGBA")) or (
- self.mode == "RGB" and mode == "RGBA"
- ):
- # Use transparent conversion to promote from transparent
- # color to an alpha channel.
- new_im = self._new(
- self.im.convert_transparent(mode, self.info["transparency"])
- )
- del new_im.info["transparency"]
- return new_im
- elif self.mode in ("L", "RGB", "P") and mode in ("L", "RGB", "P"):
- t = self.info["transparency"]
- if isinstance(t, bytes):
- # Dragons. This can't be represented by a single color
- warnings.warn(
- "Palette images with Transparency expressed in bytes should be "
- "converted to RGBA images"
- )
- delete_trns = True
- else:
- # get the new transparency color.
- # use existing conversions
- trns_im = Image()._new(core.new(self.mode, (1, 1)))
- if self.mode == "P":
- trns_im.putpalette(self.palette)
- if isinstance(t, tuple):
- err = "Couldn't allocate a palette color for transparency"
- try:
- t = trns_im.palette.getcolor(t, self)
- except ValueError as e:
- if str(e) == "cannot allocate more than 256 colors":
- # If all 256 colors are in use,
- # then there is no need for transparency
- t = None
- else:
- raise ValueError(err) from e
- if t is None:
- trns = None
- else:
- trns_im.putpixel((0, 0), t)
-
- if mode in ("L", "RGB"):
- trns_im = trns_im.convert(mode)
- else:
- # can't just retrieve the palette number, got to do it
- # after quantization.
- trns_im = trns_im.convert("RGB")
- trns = trns_im.getpixel((0, 0))
-
- elif self.mode == "P" and mode in ("LA", "PA", "RGBA"):
- t = self.info["transparency"]
- delete_trns = True
-
- if isinstance(t, bytes):
- self.im.putpalettealphas(t)
- elif isinstance(t, int):
- self.im.putpalettealpha(t, 0)
- else:
- raise ValueError("Transparency for P mode should be bytes or int")
-
- if mode == "P" and palette == Palette.ADAPTIVE:
- im = self.im.quantize(colors)
- new = self._new(im)
- from . import ImagePalette
-
- new.palette = ImagePalette.ImagePalette("RGB", new.im.getpalette("RGB"))
- if delete_trns:
- # This could possibly happen if we requantize to fewer colors.
- # The transparency would be totally off in that case.
- del new.info["transparency"]
- if trns is not None:
- try:
- new.info["transparency"] = new.palette.getcolor(trns, new)
- except Exception:
- # if we can't make a transparent color, don't leave the old
- # transparency hanging around to mess us up.
- del new.info["transparency"]
- warnings.warn("Couldn't allocate palette entry for transparency")
- return new
-
- if "LAB" in (self.mode, mode):
- other_mode = mode if self.mode == "LAB" else self.mode
- if other_mode in ("RGB", "RGBA", "RGBX"):
- from . import ImageCms
-
- srgb = ImageCms.createProfile("sRGB")
- lab = ImageCms.createProfile("LAB")
- profiles = [lab, srgb] if self.mode == "LAB" else [srgb, lab]
- transform = ImageCms.buildTransform(
- profiles[0], profiles[1], self.mode, mode
- )
- return transform.apply(self)
-
- # colorspace conversion
- if dither is None:
- dither = Dither.FLOYDSTEINBERG
-
- try:
- im = self.im.convert(mode, dither)
- except ValueError:
- try:
- # normalize source image and try again
- modebase = getmodebase(self.mode)
- if modebase == self.mode:
- raise
- im = self.im.convert(modebase)
- im = im.convert(mode, dither)
- except KeyError as e:
- raise ValueError("illegal conversion") from e
-
- new_im = self._new(im)
- if mode == "P" and palette != Palette.ADAPTIVE:
- from . import ImagePalette
-
- new_im.palette = ImagePalette.ImagePalette("RGB", list(range(256)) * 3)
- if delete_trns:
- # crash fail if we leave a bytes transparency in an rgb/l mode.
- del new_im.info["transparency"]
- if trns is not None:
- if new_im.mode == "P":
- try:
- new_im.info["transparency"] = new_im.palette.getcolor(trns, new_im)
- except ValueError as e:
- del new_im.info["transparency"]
- if str(e) != "cannot allocate more than 256 colors":
- # If all 256 colors are in use,
- # then there is no need for transparency
- warnings.warn(
- "Couldn't allocate palette entry for transparency"
- )
- else:
- new_im.info["transparency"] = trns
- return new_im
-
- def quantize(
- self,
- colors=256,
- method=None,
- kmeans=0,
- palette=None,
- dither=Dither.FLOYDSTEINBERG,
- ):
- """
- Convert the image to 'P' mode with the specified number
- of colors.
-
- :param colors: The desired number of colors, <= 256
- :param method: :data:`Quantize.MEDIANCUT` (median cut),
- :data:`Quantize.MAXCOVERAGE` (maximum coverage),
- :data:`Quantize.FASTOCTREE` (fast octree),
- :data:`Quantize.LIBIMAGEQUANT` (libimagequant; check support
- using :py:func:`PIL.features.check_feature` with
- ``feature="libimagequant"``).
-
- By default, :data:`Quantize.MEDIANCUT` will be used.
-
- The exception to this is RGBA images. :data:`Quantize.MEDIANCUT`
- and :data:`Quantize.MAXCOVERAGE` do not support RGBA images, so
- :data:`Quantize.FASTOCTREE` is used by default instead.
- :param kmeans: Integer
- :param palette: Quantize to the palette of given
- :py:class:`PIL.Image.Image`.
- :param dither: Dithering method, used when converting from
- mode "RGB" to "P" or from "RGB" or "L" to "1".
- Available methods are :data:`Dither.NONE` or :data:`Dither.FLOYDSTEINBERG`
- (default).
- :returns: A new image
-
- """
-
- self.load()
-
- if method is None:
- # defaults:
- method = Quantize.MEDIANCUT
- if self.mode == "RGBA":
- method = Quantize.FASTOCTREE
-
- if self.mode == "RGBA" and method not in (
- Quantize.FASTOCTREE,
- Quantize.LIBIMAGEQUANT,
- ):
- # Caller specified an invalid mode.
- raise ValueError(
- "Fast Octree (method == 2) and libimagequant (method == 3) "
- "are the only valid methods for quantizing RGBA images"
- )
-
- if palette:
- # use palette from reference image
- palette.load()
- if palette.mode != "P":
- raise ValueError("bad mode for palette image")
- if self.mode != "RGB" and self.mode != "L":
- raise ValueError(
- "only RGB or L mode images can be quantized to a palette"
- )
- im = self.im.convert("P", dither, palette.im)
- new_im = self._new(im)
- new_im.palette = palette.palette.copy()
- return new_im
-
- im = self._new(self.im.quantize(colors, method, kmeans))
-
- from . import ImagePalette
-
- mode = im.im.getpalettemode()
- palette = im.im.getpalette(mode, mode)[: colors * len(mode)]
- im.palette = ImagePalette.ImagePalette(mode, palette)
-
- return im
-
- def copy(self):
- """
- Copies this image. Use this method if you wish to paste things
- into an image, but still retain the original.
-
- :rtype: :py:class:`~PIL.Image.Image`
- :returns: An :py:class:`~PIL.Image.Image` object.
- """
- self.load()
- return self._new(self.im.copy())
-
- __copy__ = copy
-
- def crop(self, box=None):
- """
- Returns a rectangular region from this image. The box is a
- 4-tuple defining the left, upper, right, and lower pixel
- coordinate. See :ref:`coordinate-system`.
-
- Note: Prior to Pillow 3.4.0, this was a lazy operation.
-
- :param box: The crop rectangle, as a (left, upper, right, lower)-tuple.
- :rtype: :py:class:`~PIL.Image.Image`
- :returns: An :py:class:`~PIL.Image.Image` object.
- """
-
- if box is None:
- return self.copy()
-
- if box[2] < box[0]:
- raise ValueError("Coordinate 'right' is less than 'left'")
- elif box[3] < box[1]:
- raise ValueError("Coordinate 'lower' is less than 'upper'")
-
- self.load()
- return self._new(self._crop(self.im, box))
-
- def _crop(self, im, box):
- """
- Returns a rectangular region from the core image object im.
-
- This is equivalent to calling im.crop((x0, y0, x1, y1)), but
- includes additional sanity checks.
-
- :param im: a core image object
- :param box: The crop rectangle, as a (left, upper, right, lower)-tuple.
- :returns: A core image object.
- """
-
- x0, y0, x1, y1 = map(int, map(round, box))
-
- absolute_values = (abs(x1 - x0), abs(y1 - y0))
-
- _decompression_bomb_check(absolute_values)
-
- return im.crop((x0, y0, x1, y1))
-
- def draft(self, mode, size):
- """
- Configures the image file loader so it returns a version of the
- image that as closely as possible matches the given mode and
- size. For example, you can use this method to convert a color
- JPEG to greyscale while loading it.
-
- If any changes are made, returns a tuple with the chosen ``mode`` and
- ``box`` with coordinates of the original image within the altered one.
-
- Note that this method modifies the :py:class:`~PIL.Image.Image` object
- in place. If the image has already been loaded, this method has no
- effect.
-
- Note: This method is not implemented for most images. It is
- currently implemented only for JPEG and MPO images.
-
- :param mode: The requested mode.
- :param size: The requested size.
- """
- pass
-
- def _expand(self, xmargin, ymargin=None):
- if ymargin is None:
- ymargin = xmargin
- self.load()
- return self._new(self.im.expand(xmargin, ymargin, 0))
-
- def filter(self, filter):
- """
- Filters this image using the given filter. For a list of
- available filters, see the :py:mod:`~PIL.ImageFilter` module.
-
- :param filter: Filter kernel.
- :returns: An :py:class:`~PIL.Image.Image` object."""
-
- from . import ImageFilter
-
- self.load()
-
- if isinstance(filter, Callable):
- filter = filter()
- if not hasattr(filter, "filter"):
- raise TypeError(
- "filter argument should be ImageFilter.Filter instance or class"
- )
-
- multiband = isinstance(filter, ImageFilter.MultibandFilter)
- if self.im.bands == 1 or multiband:
- return self._new(filter.filter(self.im))
-
- ims = []
- for c in range(self.im.bands):
- ims.append(self._new(filter.filter(self.im.getband(c))))
- return merge(self.mode, ims)
-
- def getbands(self):
- """
- Returns a tuple containing the name of each band in this image.
- For example, ``getbands`` on an RGB image returns ("R", "G", "B").
-
- :returns: A tuple containing band names.
- :rtype: tuple
- """
- return ImageMode.getmode(self.mode).bands
-
- def getbbox(self):
- """
- Calculates the bounding box of the non-zero regions in the
- image.
-
- :returns: The bounding box is returned as a 4-tuple defining the
- left, upper, right, and lower pixel coordinate. See
- :ref:`coordinate-system`. If the image is completely empty, this
- method returns None.
-
- """
-
- self.load()
- return self.im.getbbox()
-
- def getcolors(self, maxcolors=256):
- """
- Returns a list of colors used in this image.
-
- The colors will be in the image's mode. For example, an RGB image will
- return a tuple of (red, green, blue) color values, and a P image will
- return the index of the color in the palette.
-
- :param maxcolors: Maximum number of colors. If this number is
- exceeded, this method returns None. The default limit is
- 256 colors.
- :returns: An unsorted list of (count, pixel) values.
- """
-
- self.load()
- if self.mode in ("1", "L", "P"):
- h = self.im.histogram()
- out = []
- for i in range(256):
- if h[i]:
- out.append((h[i], i))
- if len(out) > maxcolors:
- return None
- return out
- return self.im.getcolors(maxcolors)
-
- def getdata(self, band=None):
- """
- Returns the contents of this image as a sequence object
- containing pixel values. The sequence object is flattened, so
- that values for line one follow directly after the values of
- line zero, and so on.
-
- Note that the sequence object returned by this method is an
- internal PIL data type, which only supports certain sequence
- operations. To convert it to an ordinary sequence (e.g. for
- printing), use ``list(im.getdata())``.
-
- :param band: What band to return. The default is to return
- all bands. To return a single band, pass in the index
- value (e.g. 0 to get the "R" band from an "RGB" image).
- :returns: A sequence-like object.
- """
-
- self.load()
- if band is not None:
- return self.im.getband(band)
- return self.im # could be abused
-
- def getextrema(self):
- """
- Gets the minimum and maximum pixel values for each band in
- the image.
-
- :returns: For a single-band image, a 2-tuple containing the
- minimum and maximum pixel value. For a multi-band image,
- a tuple containing one 2-tuple for each band.
- """
-
- self.load()
- if self.im.bands > 1:
- extrema = []
- for i in range(self.im.bands):
- extrema.append(self.im.getband(i).getextrema())
- return tuple(extrema)
- return self.im.getextrema()
-
- def _getxmp(self, xmp_tags):
- def get_name(tag):
- return tag.split("}")[1]
-
- def get_value(element):
- value = {get_name(k): v for k, v in element.attrib.items()}
- children = list(element)
- if children:
- for child in children:
- name = get_name(child.tag)
- child_value = get_value(child)
- if name in value:
- if not isinstance(value[name], list):
- value[name] = [value[name]]
- value[name].append(child_value)
- else:
- value[name] = child_value
- elif value:
- if element.text:
- value["text"] = element.text
- else:
- return element.text
- return value
-
- if ElementTree is None:
- warnings.warn("XMP data cannot be read without defusedxml dependency")
- return {}
- else:
- root = ElementTree.fromstring(xmp_tags)
- return {get_name(root.tag): get_value(root)}
-
- def getexif(self):
- if self._exif is None:
- self._exif = Exif()
- self._exif._loaded = False
- elif self._exif._loaded:
- return self._exif
- self._exif._loaded = True
-
- exif_info = self.info.get("exif")
- if exif_info is None:
- if "Raw profile type exif" in self.info:
- exif_info = bytes.fromhex(
- "".join(self.info["Raw profile type exif"].split("\n")[3:])
- )
- elif hasattr(self, "tag_v2"):
- self._exif.bigtiff = self.tag_v2._bigtiff
- self._exif.endian = self.tag_v2._endian
- self._exif.load_from_fp(self.fp, self.tag_v2._offset)
- if exif_info is not None:
- self._exif.load(exif_info)
-
- # XMP tags
- if 0x0112 not in self._exif:
- xmp_tags = self.info.get("XML:com.adobe.xmp")
- if xmp_tags:
- match = re.search(r'tiff:Orientation(="|>)([0-9])', xmp_tags)
- if match:
- self._exif[0x0112] = int(match[2])
-
- return self._exif
-
- def _reload_exif(self):
- if self._exif is None or not self._exif._loaded:
- return
- self._exif._loaded = False
- self.getexif()
-
- def getim(self):
- """
- Returns a capsule that points to the internal image memory.
-
- :returns: A capsule object.
- """
-
- self.load()
- return self.im.ptr
-
- def getpalette(self, rawmode="RGB"):
- """
- Returns the image palette as a list.
-
- :param rawmode: The mode in which to return the palette. ``None`` will
- return the palette in its current mode.
-
- .. versionadded:: 9.1.0
-
- :returns: A list of color values [r, g, b, ...], or None if the
- image has no palette.
- """
-
- self.load()
- try:
- mode = self.im.getpalettemode()
- except ValueError:
- return None # no palette
- if rawmode is None:
- rawmode = mode
- return list(self.im.getpalette(mode, rawmode))
-
- def apply_transparency(self):
- """
- If a P mode image has a "transparency" key in the info dictionary,
- remove the key and apply the transparency to the palette instead.
- """
- if self.mode != "P" or "transparency" not in self.info:
- return
-
- from . import ImagePalette
-
- palette = self.getpalette("RGBA")
- transparency = self.info["transparency"]
- if isinstance(transparency, bytes):
- for i, alpha in enumerate(transparency):
- palette[i * 4 + 3] = alpha
- else:
- palette[transparency * 4 + 3] = 0
- self.palette = ImagePalette.ImagePalette("RGBA", bytes(palette))
- self.palette.dirty = 1
-
- del self.info["transparency"]
-
- def getpixel(self, xy):
- """
- Returns the pixel value at a given position.
-
- :param xy: The coordinate, given as (x, y). See
- :ref:`coordinate-system`.
- :returns: The pixel value. If the image is a multi-layer image,
- this method returns a tuple.
- """
-
- self.load()
- if self.pyaccess:
- return self.pyaccess.getpixel(xy)
- return self.im.getpixel(xy)
-
- def getprojection(self):
- """
- Get projection to x and y axes
-
- :returns: Two sequences, indicating where there are non-zero
- pixels along the X-axis and the Y-axis, respectively.
- """
-
- self.load()
- x, y = self.im.getprojection()
- return list(x), list(y)
-
- def histogram(self, mask=None, extrema=None):
- """
- Returns a histogram for the image. The histogram is returned as a
- list of pixel counts, one for each pixel value in the source
- image. Counts are grouped into 256 bins for each band, even if
- the image has more than 8 bits per band. If the image has more
- than one band, the histograms for all bands are concatenated (for
- example, the histogram for an "RGB" image contains 768 values).
-
- A bilevel image (mode "1") is treated as a greyscale ("L") image
- by this method.
-
- If a mask is provided, the method returns a histogram for those
- parts of the image where the mask image is non-zero. The mask
- image must have the same size as the image, and be either a
- bi-level image (mode "1") or a greyscale image ("L").
-
- :param mask: An optional mask.
- :param extrema: An optional tuple of manually-specified extrema.
- :returns: A list containing pixel counts.
- """
- self.load()
- if mask:
- mask.load()
- return self.im.histogram((0, 0), mask.im)
- if self.mode in ("I", "F"):
- if extrema is None:
- extrema = self.getextrema()
- return self.im.histogram(extrema)
- return self.im.histogram()
-
- def entropy(self, mask=None, extrema=None):
- """
- Calculates and returns the entropy for the image.
-
- A bilevel image (mode "1") is treated as a greyscale ("L")
- image by this method.
-
- If a mask is provided, the method employs the histogram for
- those parts of the image where the mask image is non-zero.
- The mask image must have the same size as the image, and be
- either a bi-level image (mode "1") or a greyscale image ("L").
-
- :param mask: An optional mask.
- :param extrema: An optional tuple of manually-specified extrema.
- :returns: A float value representing the image entropy
- """
- self.load()
- if mask:
- mask.load()
- return self.im.entropy((0, 0), mask.im)
- if self.mode in ("I", "F"):
- if extrema is None:
- extrema = self.getextrema()
- return self.im.entropy(extrema)
- return self.im.entropy()
-
- def paste(self, im, box=None, mask=None):
- """
- Pastes another image into this image. The box argument is either
- a 2-tuple giving the upper left corner, a 4-tuple defining the
- left, upper, right, and lower pixel coordinate, or None (same as
- (0, 0)). See :ref:`coordinate-system`. If a 4-tuple is given, the size
- of the pasted image must match the size of the region.
-
- If the modes don't match, the pasted image is converted to the mode of
- this image (see the :py:meth:`~PIL.Image.Image.convert` method for
- details).
-
- Instead of an image, the source can be a integer or tuple
- containing pixel values. The method then fills the region
- with the given color. When creating RGB images, you can
- also use color strings as supported by the ImageColor module.
-
- If a mask is given, this method updates only the regions
- indicated by the mask. You can use either "1", "L", "LA", "RGBA"
- or "RGBa" images (if present, the alpha band is used as mask).
- Where the mask is 255, the given image is copied as is. Where
- the mask is 0, the current value is preserved. Intermediate
- values will mix the two images together, including their alpha
- channels if they have them.
-
- See :py:meth:`~PIL.Image.Image.alpha_composite` if you want to
- combine images with respect to their alpha channels.
-
- :param im: Source image or pixel value (integer or tuple).
- :param box: An optional 4-tuple giving the region to paste into.
- If a 2-tuple is used instead, it's treated as the upper left
- corner. If omitted or None, the source is pasted into the
- upper left corner.
-
- If an image is given as the second argument and there is no
- third, the box defaults to (0, 0), and the second argument
- is interpreted as a mask image.
- :param mask: An optional mask image.
- """
-
- if isImageType(box) and mask is None:
- # abbreviated paste(im, mask) syntax
- mask = box
- box = None
-
- if box is None:
- box = (0, 0)
-
- if len(box) == 2:
- # upper left corner given; get size from image or mask
- if isImageType(im):
- size = im.size
- elif isImageType(mask):
- size = mask.size
- else:
- # FIXME: use self.size here?
- raise ValueError("cannot determine region size; use 4-item box")
- box += (box[0] + size[0], box[1] + size[1])
-
- if isinstance(im, str):
- from . import ImageColor
-
- im = ImageColor.getcolor(im, self.mode)
-
- elif isImageType(im):
- im.load()
- if self.mode != im.mode:
- if self.mode != "RGB" or im.mode not in ("LA", "RGBA", "RGBa"):
- # should use an adapter for this!
- im = im.convert(self.mode)
- im = im.im
-
- self._ensure_mutable()
-
- if mask:
- mask.load()
- self.im.paste(im, box, mask.im)
- else:
- self.im.paste(im, box)
-
- def alpha_composite(self, im, dest=(0, 0), source=(0, 0)):
- """'In-place' analog of Image.alpha_composite. Composites an image
- onto this image.
-
- :param im: image to composite over this one
- :param dest: Optional 2 tuple (left, top) specifying the upper
- left corner in this (destination) image.
- :param source: Optional 2 (left, top) tuple for the upper left
- corner in the overlay source image, or 4 tuple (left, top, right,
- bottom) for the bounds of the source rectangle
-
- Performance Note: Not currently implemented in-place in the core layer.
- """
-
- if not isinstance(source, (list, tuple)):
- raise ValueError("Source must be a tuple")
- if not isinstance(dest, (list, tuple)):
- raise ValueError("Destination must be a tuple")
- if not len(source) in (2, 4):
- raise ValueError("Source must be a 2 or 4-tuple")
- if not len(dest) == 2:
- raise ValueError("Destination must be a 2-tuple")
- if min(source) < 0:
- raise ValueError("Source must be non-negative")
-
- if len(source) == 2:
- source = source + im.size
-
- # over image, crop if it's not the whole thing.
- if source == (0, 0) + im.size:
- overlay = im
- else:
- overlay = im.crop(source)
-
- # target for the paste
- box = dest + (dest[0] + overlay.width, dest[1] + overlay.height)
-
- # destination image. don't copy if we're using the whole image.
- if box == (0, 0) + self.size:
- background = self
- else:
- background = self.crop(box)
-
- result = alpha_composite(background, overlay)
- self.paste(result, box)
-
- def point(self, lut, mode=None):
- """
- Maps this image through a lookup table or function.
-
- :param lut: A lookup table, containing 256 (or 65536 if
- self.mode=="I" and mode == "L") values per band in the
- image. A function can be used instead, it should take a
- single argument. The function is called once for each
- possible pixel value, and the resulting table is applied to
- all bands of the image.
-
- It may also be an :py:class:`~PIL.Image.ImagePointHandler`
- object::
-
- class Example(Image.ImagePointHandler):
- def point(self, data):
- # Return result
- :param mode: Output mode (default is same as input). In the
- current version, this can only be used if the source image
- has mode "L" or "P", and the output has mode "1" or the
- source image mode is "I" and the output mode is "L".
- :returns: An :py:class:`~PIL.Image.Image` object.
- """
-
- self.load()
-
- if isinstance(lut, ImagePointHandler):
- return lut.point(self)
-
- if callable(lut):
- # if it isn't a list, it should be a function
- if self.mode in ("I", "I;16", "F"):
- # check if the function can be used with point_transform
- # UNDONE wiredfool -- I think this prevents us from ever doing
- # a gamma function point transform on > 8bit images.
- scale, offset = _getscaleoffset(lut)
- return self._new(self.im.point_transform(scale, offset))
- # for other modes, convert the function to a table
- lut = [lut(i) for i in range(256)] * self.im.bands
-
- if self.mode == "F":
- # FIXME: _imaging returns a confusing error message for this case
- raise ValueError("point operation not supported for this mode")
-
- if mode != "F":
- lut = [round(i) for i in lut]
- return self._new(self.im.point(lut, mode))
-
- def putalpha(self, alpha):
- """
- Adds or replaces the alpha layer in this image. If the image
- does not have an alpha layer, it's converted to "LA" or "RGBA".
- The new layer must be either "L" or "1".
-
- :param alpha: The new alpha layer. This can either be an "L" or "1"
- image having the same size as this image, or an integer or
- other color value.
- """
-
- self._ensure_mutable()
-
- if self.mode not in ("LA", "PA", "RGBA"):
- # attempt to promote self to a matching alpha mode
- try:
- mode = getmodebase(self.mode) + "A"
- try:
- self.im.setmode(mode)
- except (AttributeError, ValueError) as e:
- # do things the hard way
- im = self.im.convert(mode)
- if im.mode not in ("LA", "PA", "RGBA"):
- raise ValueError from e # sanity check
- self.im = im
- self.pyaccess = None
- self.mode = self.im.mode
- except KeyError as e:
- raise ValueError("illegal image mode") from e
-
- if self.mode in ("LA", "PA"):
- band = 1
- else:
- band = 3
-
- if isImageType(alpha):
- # alpha layer
- if alpha.mode not in ("1", "L"):
- raise ValueError("illegal image mode")
- alpha.load()
- if alpha.mode == "1":
- alpha = alpha.convert("L")
- else:
- # constant alpha
- try:
- self.im.fillband(band, alpha)
- except (AttributeError, ValueError):
- # do things the hard way
- alpha = new("L", self.size, alpha)
- else:
- return
-
- self.im.putband(alpha.im, band)
-
- def putdata(self, data, scale=1.0, offset=0.0):
- """
- Copies pixel data from a flattened sequence object into the image. The
- values should start at the upper left corner (0, 0), continue to the
- end of the line, followed directly by the first value of the second
- line, and so on. Data will be read until either the image or the
- sequence ends. The scale and offset values are used to adjust the
- sequence values: **pixel = value*scale + offset**.
-
- :param data: A flattened sequence object.
- :param scale: An optional scale value. The default is 1.0.
- :param offset: An optional offset value. The default is 0.0.
- """
-
- self._ensure_mutable()
-
- self.im.putdata(data, scale, offset)
-
- def putpalette(self, data, rawmode="RGB"):
- """
- Attaches a palette to this image. The image must be a "P", "PA", "L"
- or "LA" image.
-
- The palette sequence must contain at most 256 colors, made up of one
- integer value for each channel in the raw mode.
- For example, if the raw mode is "RGB", then it can contain at most 768
- values, made up of red, green and blue values for the corresponding pixel
- index in the 256 colors.
- If the raw mode is "RGBA", then it can contain at most 1024 values,
- containing red, green, blue and alpha values.
-
- Alternatively, an 8-bit string may be used instead of an integer sequence.
-
- :param data: A palette sequence (either a list or a string).
- :param rawmode: The raw mode of the palette. Either "RGB", "RGBA", or a mode
- that can be transformed to "RGB" or "RGBA" (e.g. "R", "BGR;15", "RGBA;L").
- """
- from . import ImagePalette
-
- if self.mode not in ("L", "LA", "P", "PA"):
- raise ValueError("illegal image mode")
- if isinstance(data, ImagePalette.ImagePalette):
- palette = ImagePalette.raw(data.rawmode, data.palette)
- else:
- if not isinstance(data, bytes):
- data = bytes(data)
- palette = ImagePalette.raw(rawmode, data)
- self.mode = "PA" if "A" in self.mode else "P"
- self.palette = palette
- self.palette.mode = "RGB"
- self.load() # install new palette
-
- def putpixel(self, xy, value):
- """
- Modifies the pixel at the given position. The color is given as
- a single numerical value for single-band images, and a tuple for
- multi-band images. In addition to this, RGB and RGBA tuples are
- accepted for P and PA images.
-
- Note that this method is relatively slow. For more extensive changes,
- use :py:meth:`~PIL.Image.Image.paste` or the :py:mod:`~PIL.ImageDraw`
- module instead.
-
- See:
-
- * :py:meth:`~PIL.Image.Image.paste`
- * :py:meth:`~PIL.Image.Image.putdata`
- * :py:mod:`~PIL.ImageDraw`
-
- :param xy: The pixel coordinate, given as (x, y). See
- :ref:`coordinate-system`.
- :param value: The pixel value.
- """
-
- if self.readonly:
- self._copy()
- self.load()
-
- if self.pyaccess:
- return self.pyaccess.putpixel(xy, value)
-
- if (
- self.mode in ("P", "PA")
- and isinstance(value, (list, tuple))
- and len(value) in [3, 4]
- ):
- # RGB or RGBA value for a P or PA image
- if self.mode == "PA":
- alpha = value[3] if len(value) == 4 else 255
- value = value[:3]
- value = self.palette.getcolor(value, self)
- if self.mode == "PA":
- value = (value, alpha)
- return self.im.putpixel(xy, value)
-
- def remap_palette(self, dest_map, source_palette=None):
- """
- Rewrites the image to reorder the palette.
-
- :param dest_map: A list of indexes into the original palette.
- e.g. ``[1,0]`` would swap a two item palette, and ``list(range(256))``
- is the identity transform.
- :param source_palette: Bytes or None.
- :returns: An :py:class:`~PIL.Image.Image` object.
-
- """
- from . import ImagePalette
-
- if self.mode not in ("L", "P"):
- raise ValueError("illegal image mode")
-
- bands = 3
- palette_mode = "RGB"
- if source_palette is None:
- if self.mode == "P":
- self.load()
- palette_mode = self.im.getpalettemode()
- if palette_mode == "RGBA":
- bands = 4
- source_palette = self.im.getpalette(palette_mode, palette_mode)
- else: # L-mode
- source_palette = bytearray(i // 3 for i in range(768))
-
- palette_bytes = b""
- new_positions = [0] * 256
-
- # pick only the used colors from the palette
- for i, oldPosition in enumerate(dest_map):
- palette_bytes += source_palette[
- oldPosition * bands : oldPosition * bands + bands
- ]
- new_positions[oldPosition] = i
-
- # replace the palette color id of all pixel with the new id
-
- # Palette images are [0..255], mapped through a 1 or 3
- # byte/color map. We need to remap the whole image
- # from palette 1 to palette 2. New_positions is
- # an array of indexes into palette 1. Palette 2 is
- # palette 1 with any holes removed.
-
- # We're going to leverage the convert mechanism to use the
- # C code to remap the image from palette 1 to palette 2,
- # by forcing the source image into 'L' mode and adding a
- # mapping 'L' mode palette, then converting back to 'L'
- # sans palette thus converting the image bytes, then
- # assigning the optimized RGB palette.
-
- # perf reference, 9500x4000 gif, w/~135 colors
- # 14 sec prepatch, 1 sec postpatch with optimization forced.
-
- mapping_palette = bytearray(new_positions)
-
- m_im = self.copy()
- m_im.mode = "P"
-
- m_im.palette = ImagePalette.ImagePalette(
- palette_mode, palette=mapping_palette * bands
- )
- # possibly set palette dirty, then
- # m_im.putpalette(mapping_palette, 'L') # converts to 'P'
- # or just force it.
- # UNDONE -- this is part of the general issue with palettes
- m_im.im.putpalette(palette_mode + ";L", m_im.palette.tobytes())
-
- m_im = m_im.convert("L")
-
- m_im.putpalette(palette_bytes, palette_mode)
- m_im.palette = ImagePalette.ImagePalette(palette_mode, palette=palette_bytes)
-
- if "transparency" in self.info:
- try:
- m_im.info["transparency"] = dest_map.index(self.info["transparency"])
- except ValueError:
- if "transparency" in m_im.info:
- del m_im.info["transparency"]
-
- return m_im
-
- def _get_safe_box(self, size, resample, box):
- """Expands the box so it includes adjacent pixels
- that may be used by resampling with the given resampling filter.
- """
- filter_support = _filters_support[resample] - 0.5
- scale_x = (box[2] - box[0]) / size[0]
- scale_y = (box[3] - box[1]) / size[1]
- support_x = filter_support * scale_x
- support_y = filter_support * scale_y
-
- return (
- max(0, int(box[0] - support_x)),
- max(0, int(box[1] - support_y)),
- min(self.size[0], math.ceil(box[2] + support_x)),
- min(self.size[1], math.ceil(box[3] + support_y)),
- )
-
- def resize(self, size, resample=None, box=None, reducing_gap=None):
- """
- Returns a resized copy of this image.
-
- :param size: The requested size in pixels, as a 2-tuple:
- (width, height).
- :param resample: An optional resampling filter. This can be
- one of :py:data:`Resampling.NEAREST`, :py:data:`Resampling.BOX`,
- :py:data:`Resampling.BILINEAR`, :py:data:`Resampling.HAMMING`,
- :py:data:`Resampling.BICUBIC` or :py:data:`Resampling.LANCZOS`.
- If the image has mode "1" or "P", it is always set to
- :py:data:`Resampling.NEAREST`. If the image mode specifies a number
- of bits, such as "I;16", then the default filter is
- :py:data:`Resampling.NEAREST`. Otherwise, the default filter is
- :py:data:`Resampling.BICUBIC`. See: :ref:`concept-filters`.
- :param box: An optional 4-tuple of floats providing
- the source image region to be scaled.
- The values must be within (0, 0, width, height) rectangle.
- If omitted or None, the entire source is used.
- :param reducing_gap: Apply optimization by resizing the image
- in two steps. First, reducing the image by integer times
- using :py:meth:`~PIL.Image.Image.reduce`.
- Second, resizing using regular resampling. The last step
- changes size no less than by ``reducing_gap`` times.
- ``reducing_gap`` may be None (no first step is performed)
- or should be greater than 1.0. The bigger ``reducing_gap``,
- the closer the result to the fair resampling.
- The smaller ``reducing_gap``, the faster resizing.
- With ``reducing_gap`` greater or equal to 3.0, the result is
- indistinguishable from fair resampling in most cases.
- The default value is None (no optimization).
- :returns: An :py:class:`~PIL.Image.Image` object.
- """
-
- if resample is None:
- type_special = ";" in self.mode
- resample = Resampling.NEAREST if type_special else Resampling.BICUBIC
- elif resample not in (
- Resampling.NEAREST,
- Resampling.BILINEAR,
- Resampling.BICUBIC,
- Resampling.LANCZOS,
- Resampling.BOX,
- Resampling.HAMMING,
- ):
- message = f"Unknown resampling filter ({resample})."
-
- filters = [
- f"{filter[1]} ({filter[0]})"
- for filter in (
- (Resampling.NEAREST, "Image.Resampling.NEAREST"),
- (Resampling.LANCZOS, "Image.Resampling.LANCZOS"),
- (Resampling.BILINEAR, "Image.Resampling.BILINEAR"),
- (Resampling.BICUBIC, "Image.Resampling.BICUBIC"),
- (Resampling.BOX, "Image.Resampling.BOX"),
- (Resampling.HAMMING, "Image.Resampling.HAMMING"),
- )
- ]
- raise ValueError(
- message + " Use " + ", ".join(filters[:-1]) + " or " + filters[-1]
- )
-
- if reducing_gap is not None and reducing_gap < 1.0:
- raise ValueError("reducing_gap must be 1.0 or greater")
-
- size = tuple(size)
-
- self.load()
- if box is None:
- box = (0, 0) + self.size
- else:
- box = tuple(box)
-
- if self.size == size and box == (0, 0) + self.size:
- return self.copy()
-
- if self.mode in ("1", "P"):
- resample = Resampling.NEAREST
-
- if self.mode in ["LA", "RGBA"] and resample != Resampling.NEAREST:
- im = self.convert({"LA": "La", "RGBA": "RGBa"}[self.mode])
- im = im.resize(size, resample, box)
- return im.convert(self.mode)
-
- self.load()
-
- if reducing_gap is not None and resample != Resampling.NEAREST:
- factor_x = int((box[2] - box[0]) / size[0] / reducing_gap) or 1
- factor_y = int((box[3] - box[1]) / size[1] / reducing_gap) or 1
- if factor_x > 1 or factor_y > 1:
- reduce_box = self._get_safe_box(size, resample, box)
- factor = (factor_x, factor_y)
- if callable(self.reduce):
- self = self.reduce(factor, box=reduce_box)
- else:
- self = Image.reduce(self, factor, box=reduce_box)
- box = (
- (box[0] - reduce_box[0]) / factor_x,
- (box[1] - reduce_box[1]) / factor_y,
- (box[2] - reduce_box[0]) / factor_x,
- (box[3] - reduce_box[1]) / factor_y,
- )
-
- return self._new(self.im.resize(size, resample, box))
-
- def reduce(self, factor, box=None):
- """
- Returns a copy of the image reduced ``factor`` times.
- If the size of the image is not dividable by ``factor``,
- the resulting size will be rounded up.
-
- :param factor: A greater than 0 integer or tuple of two integers
- for width and height separately.
- :param box: An optional 4-tuple of ints providing
- the source image region to be reduced.
- The values must be within ``(0, 0, width, height)`` rectangle.
- If omitted or ``None``, the entire source is used.
- """
- if not isinstance(factor, (list, tuple)):
- factor = (factor, factor)
-
- if box is None:
- box = (0, 0) + self.size
- else:
- box = tuple(box)
-
- if factor == (1, 1) and box == (0, 0) + self.size:
- return self.copy()
-
- if self.mode in ["LA", "RGBA"]:
- im = self.convert({"LA": "La", "RGBA": "RGBa"}[self.mode])
- im = im.reduce(factor, box)
- return im.convert(self.mode)
-
- self.load()
-
- return self._new(self.im.reduce(factor, box))
-
- def rotate(
- self,
- angle,
- resample=Resampling.NEAREST,
- expand=0,
- center=None,
- translate=None,
- fillcolor=None,
- ):
- """
- Returns a rotated copy of this image. This method returns a
- copy of this image, rotated the given number of degrees counter
- clockwise around its centre.
-
- :param angle: In degrees counter clockwise.
- :param resample: An optional resampling filter. This can be
- one of :py:data:`Resampling.NEAREST` (use nearest neighbour),
- :py:data:`Resampling.BILINEAR` (linear interpolation in a 2x2
- environment), or :py:data:`Resampling.BICUBIC` (cubic spline
- interpolation in a 4x4 environment). If omitted, or if the image has
- mode "1" or "P", it is set to :py:data:`Resampling.NEAREST`.
- See :ref:`concept-filters`.
- :param expand: Optional expansion flag. If true, expands the output
- image to make it large enough to hold the entire rotated image.
- If false or omitted, make the output image the same size as the
- input image. Note that the expand flag assumes rotation around
- the center and no translation.
- :param center: Optional center of rotation (a 2-tuple). Origin is
- the upper left corner. Default is the center of the image.
- :param translate: An optional post-rotate translation (a 2-tuple).
- :param fillcolor: An optional color for area outside the rotated image.
- :returns: An :py:class:`~PIL.Image.Image` object.
- """
-
- angle = angle % 360.0
-
- # Fast paths regardless of filter, as long as we're not
- # translating or changing the center.
- if not (center or translate):
- if angle == 0:
- return self.copy()
- if angle == 180:
- return self.transpose(Transpose.ROTATE_180)
- if angle in (90, 270) and (expand or self.width == self.height):
- return self.transpose(
- Transpose.ROTATE_90 if angle == 90 else Transpose.ROTATE_270
- )
-
- # Calculate the affine matrix. Note that this is the reverse
- # transformation (from destination image to source) because we
- # want to interpolate the (discrete) destination pixel from
- # the local area around the (floating) source pixel.
-
- # The matrix we actually want (note that it operates from the right):
- # (1, 0, tx) (1, 0, cx) ( cos a, sin a, 0) (1, 0, -cx)
- # (0, 1, ty) * (0, 1, cy) * (-sin a, cos a, 0) * (0, 1, -cy)
- # (0, 0, 1) (0, 0, 1) ( 0, 0, 1) (0, 0, 1)
-
- # The reverse matrix is thus:
- # (1, 0, cx) ( cos -a, sin -a, 0) (1, 0, -cx) (1, 0, -tx)
- # (0, 1, cy) * (-sin -a, cos -a, 0) * (0, 1, -cy) * (0, 1, -ty)
- # (0, 0, 1) ( 0, 0, 1) (0, 0, 1) (0, 0, 1)
-
- # In any case, the final translation may be updated at the end to
- # compensate for the expand flag.
-
- w, h = self.size
-
- if translate is None:
- post_trans = (0, 0)
- else:
- post_trans = translate
- if center is None:
- # FIXME These should be rounded to ints?
- rotn_center = (w / 2.0, h / 2.0)
- else:
- rotn_center = center
-
- angle = -math.radians(angle)
- matrix = [
- round(math.cos(angle), 15),
- round(math.sin(angle), 15),
- 0.0,
- round(-math.sin(angle), 15),
- round(math.cos(angle), 15),
- 0.0,
- ]
-
- def transform(x, y, matrix):
- (a, b, c, d, e, f) = matrix
- return a * x + b * y + c, d * x + e * y + f
-
- matrix[2], matrix[5] = transform(
- -rotn_center[0] - post_trans[0], -rotn_center[1] - post_trans[1], matrix
- )
- matrix[2] += rotn_center[0]
- matrix[5] += rotn_center[1]
-
- if expand:
- # calculate output size
- xx = []
- yy = []
- for x, y in ((0, 0), (w, 0), (w, h), (0, h)):
- x, y = transform(x, y, matrix)
- xx.append(x)
- yy.append(y)
- nw = math.ceil(max(xx)) - math.floor(min(xx))
- nh = math.ceil(max(yy)) - math.floor(min(yy))
-
- # We multiply a translation matrix from the right. Because of its
- # special form, this is the same as taking the image of the
- # translation vector as new translation vector.
- matrix[2], matrix[5] = transform(-(nw - w) / 2.0, -(nh - h) / 2.0, matrix)
- w, h = nw, nh
-
- return self.transform(
- (w, h), Transform.AFFINE, matrix, resample, fillcolor=fillcolor
- )
-
- def save(self, fp, format=None, **params):
- """
- Saves this image under the given filename. If no format is
- specified, the format to use is determined from the filename
- extension, if possible.
-
- Keyword options can be used to provide additional instructions
- to the writer. If a writer doesn't recognise an option, it is
- silently ignored. The available options are described in the
- :doc:`image format documentation
- <../handbook/image-file-formats>` for each writer.
-
- You can use a file object instead of a filename. In this case,
- you must always specify the format. The file object must
- implement the ``seek``, ``tell``, and ``write``
- methods, and be opened in binary mode.
-
- :param fp: A filename (string), pathlib.Path object or file object.
- :param format: Optional format override. If omitted, the
- format to use is determined from the filename extension.
- If a file object was used instead of a filename, this
- parameter should always be used.
- :param params: Extra parameters to the image writer.
- :returns: None
- :exception ValueError: If the output format could not be determined
- from the file name. Use the format option to solve this.
- :exception OSError: If the file could not be written. The file
- may have been created, and may contain partial data.
- """
-
- filename = ""
- open_fp = False
- if isinstance(fp, Path):
- filename = str(fp)
- open_fp = True
- elif is_path(fp):
- filename = fp
- open_fp = True
- elif fp == sys.stdout:
- try:
- fp = sys.stdout.buffer
- except AttributeError:
- pass
- if not filename and hasattr(fp, "name") and is_path(fp.name):
- # only set the name for metadata purposes
- filename = fp.name
-
- # may mutate self!
- self._ensure_mutable()
-
- save_all = params.pop("save_all", False)
- self.encoderinfo = params
- self.encoderconfig = ()
-
- preinit()
-
- ext = os.path.splitext(filename)[1].lower()
-
- if not format:
- if ext not in EXTENSION:
- init()
- try:
- format = EXTENSION[ext]
- except KeyError as e:
- raise ValueError(f"unknown file extension: {ext}") from e
-
- if format.upper() not in SAVE:
- init()
- if save_all:
- save_handler = SAVE_ALL[format.upper()]
- else:
- save_handler = SAVE[format.upper()]
-
- created = False
- if open_fp:
- created = not os.path.exists(filename)
- if params.get("append", False):
- # Open also for reading ("+"), because TIFF save_all
- # writer needs to go back and edit the written data.
- fp = builtins.open(filename, "r+b")
- else:
- fp = builtins.open(filename, "w+b")
-
- try:
- save_handler(self, fp, filename)
- except Exception:
- if open_fp:
- fp.close()
- if created:
- try:
- os.remove(filename)
- except PermissionError:
- pass
- raise
- if open_fp:
- fp.close()
-
- def seek(self, frame):
- """
- Seeks to the given frame in this sequence file. If you seek
- beyond the end of the sequence, the method raises an
- ``EOFError`` exception. When a sequence file is opened, the
- library automatically seeks to frame 0.
-
- See :py:meth:`~PIL.Image.Image.tell`.
-
- If defined, :attr:`~PIL.Image.Image.n_frames` refers to the
- number of available frames.
-
- :param frame: Frame number, starting at 0.
- :exception EOFError: If the call attempts to seek beyond the end
- of the sequence.
- """
-
- # overridden by file handlers
- if frame != 0:
- raise EOFError
-
- def show(self, title=None):
- """
- Displays this image. This method is mainly intended for debugging purposes.
-
- This method calls :py:func:`PIL.ImageShow.show` internally. You can use
- :py:func:`PIL.ImageShow.register` to override its default behaviour.
-
- The image is first saved to a temporary file. By default, it will be in
- PNG format.
-
- On Unix, the image is then opened using the **display**, **eog** or
- **xv** utility, depending on which one can be found.
-
- On macOS, the image is opened with the native Preview application.
-
- On Windows, the image is opened with the standard PNG display utility.
-
- :param title: Optional title to use for the image window, where possible.
- """
-
- _show(self, title=title)
-
- def split(self):
- """
- Split this image into individual bands. This method returns a
- tuple of individual image bands from an image. For example,
- splitting an "RGB" image creates three new images each
- containing a copy of one of the original bands (red, green,
- blue).
-
- If you need only one band, :py:meth:`~PIL.Image.Image.getchannel`
- method can be more convenient and faster.
-
- :returns: A tuple containing bands.
- """
-
- self.load()
- if self.im.bands == 1:
- ims = [self.copy()]
- else:
- ims = map(self._new, self.im.split())
- return tuple(ims)
-
- def getchannel(self, channel):
- """
- Returns an image containing a single channel of the source image.
-
- :param channel: What channel to return. Could be index
- (0 for "R" channel of "RGB") or channel name
- ("A" for alpha channel of "RGBA").
- :returns: An image in "L" mode.
-
- .. versionadded:: 4.3.0
- """
- self.load()
-
- if isinstance(channel, str):
- try:
- channel = self.getbands().index(channel)
- except ValueError as e:
- raise ValueError(f'The image has no channel "{channel}"') from e
-
- return self._new(self.im.getband(channel))
-
- def tell(self):
- """
- Returns the current frame number. See :py:meth:`~PIL.Image.Image.seek`.
-
- If defined, :attr:`~PIL.Image.Image.n_frames` refers to the
- number of available frames.
-
- :returns: Frame number, starting with 0.
- """
- return 0
-
- def thumbnail(self, size, resample=Resampling.BICUBIC, reducing_gap=2.0):
- """
- Make this image into a thumbnail. This method modifies the
- image to contain a thumbnail version of itself, no larger than
- the given size. This method calculates an appropriate thumbnail
- size to preserve the aspect of the image, calls the
- :py:meth:`~PIL.Image.Image.draft` method to configure the file reader
- (where applicable), and finally resizes the image.
-
- Note that this function modifies the :py:class:`~PIL.Image.Image`
- object in place. If you need to use the full resolution image as well,
- apply this method to a :py:meth:`~PIL.Image.Image.copy` of the original
- image.
-
- :param size: Requested size.
- :param resample: Optional resampling filter. This can be one
- of :py:data:`Resampling.NEAREST`, :py:data:`Resampling.BOX`,
- :py:data:`Resampling.BILINEAR`, :py:data:`Resampling.HAMMING`,
- :py:data:`Resampling.BICUBIC` or :py:data:`Resampling.LANCZOS`.
- If omitted, it defaults to :py:data:`Resampling.BICUBIC`.
- (was :py:data:`Resampling.NEAREST` prior to version 2.5.0).
- See: :ref:`concept-filters`.
- :param reducing_gap: Apply optimization by resizing the image
- in two steps. First, reducing the image by integer times
- using :py:meth:`~PIL.Image.Image.reduce` or
- :py:meth:`~PIL.Image.Image.draft` for JPEG images.
- Second, resizing using regular resampling. The last step
- changes size no less than by ``reducing_gap`` times.
- ``reducing_gap`` may be None (no first step is performed)
- or should be greater than 1.0. The bigger ``reducing_gap``,
- the closer the result to the fair resampling.
- The smaller ``reducing_gap``, the faster resizing.
- With ``reducing_gap`` greater or equal to 3.0, the result is
- indistinguishable from fair resampling in most cases.
- The default value is 2.0 (very close to fair resampling
- while still being faster in many cases).
- :returns: None
- """
-
- provided_size = tuple(map(math.floor, size))
-
- def preserve_aspect_ratio():
- def round_aspect(number, key):
- return max(min(math.floor(number), math.ceil(number), key=key), 1)
-
- x, y = provided_size
- if x >= self.width and y >= self.height:
- return
-
- aspect = self.width / self.height
- if x / y >= aspect:
- x = round_aspect(y * aspect, key=lambda n: abs(aspect - n / y))
- else:
- y = round_aspect(
- x / aspect, key=lambda n: 0 if n == 0 else abs(aspect - x / n)
- )
- return x, y
-
- box = None
- if reducing_gap is not None:
- size = preserve_aspect_ratio()
- if size is None:
- return
-
- res = self.draft(None, (size[0] * reducing_gap, size[1] * reducing_gap))
- if res is not None:
- box = res[1]
- if box is None:
- self.load()
-
- # load() may have changed the size of the image
- size = preserve_aspect_ratio()
- if size is None:
- return
-
- if self.size != size:
- im = self.resize(size, resample, box=box, reducing_gap=reducing_gap)
-
- self.im = im.im
- self._size = size
- self.mode = self.im.mode
-
- self.readonly = 0
- self.pyaccess = None
-
- # FIXME: the different transform methods need further explanation
- # instead of bloating the method docs, add a separate chapter.
- def transform(
- self,
- size,
- method,
- data=None,
- resample=Resampling.NEAREST,
- fill=1,
- fillcolor=None,
- ):
- """
- Transforms this image. This method creates a new image with the
- given size, and the same mode as the original, and copies data
- to the new image using the given transform.
-
- :param size: The output size.
- :param method: The transformation method. This is one of
- :py:data:`Transform.EXTENT` (cut out a rectangular subregion),
- :py:data:`Transform.AFFINE` (affine transform),
- :py:data:`Transform.PERSPECTIVE` (perspective transform),
- :py:data:`Transform.QUAD` (map a quadrilateral to a rectangle), or
- :py:data:`Transform.MESH` (map a number of source quadrilaterals
- in one operation).
-
- It may also be an :py:class:`~PIL.Image.ImageTransformHandler`
- object::
-
- class Example(Image.ImageTransformHandler):
- def transform(self, size, data, resample, fill=1):
- # Return result
-
- It may also be an object with a ``method.getdata`` method
- that returns a tuple supplying new ``method`` and ``data`` values::
-
- class Example:
- def getdata(self):
- method = Image.Transform.EXTENT
- data = (0, 0, 100, 100)
- return method, data
- :param data: Extra data to the transformation method.
- :param resample: Optional resampling filter. It can be one of
- :py:data:`Resampling.NEAREST` (use nearest neighbour),
- :py:data:`Resampling.BILINEAR` (linear interpolation in a 2x2
- environment), or :py:data:`Resampling.BICUBIC` (cubic spline
- interpolation in a 4x4 environment). If omitted, or if the image
- has mode "1" or "P", it is set to :py:data:`Resampling.NEAREST`.
- See: :ref:`concept-filters`.
- :param fill: If ``method`` is an
- :py:class:`~PIL.Image.ImageTransformHandler` object, this is one of
- the arguments passed to it. Otherwise, it is unused.
- :param fillcolor: Optional fill color for the area outside the
- transform in the output image.
- :returns: An :py:class:`~PIL.Image.Image` object.
- """
-
- if self.mode in ("LA", "RGBA") and resample != Resampling.NEAREST:
- return (
- self.convert({"LA": "La", "RGBA": "RGBa"}[self.mode])
- .transform(size, method, data, resample, fill, fillcolor)
- .convert(self.mode)
- )
-
- if isinstance(method, ImageTransformHandler):
- return method.transform(size, self, resample=resample, fill=fill)
-
- if hasattr(method, "getdata"):
- # compatibility w. old-style transform objects
- method, data = method.getdata()
-
- if data is None:
- raise ValueError("missing method data")
-
- im = new(self.mode, size, fillcolor)
- if self.mode == "P" and self.palette:
- im.palette = self.palette.copy()
- im.info = self.info.copy()
- if method == Transform.MESH:
- # list of quads
- for box, quad in data:
- im.__transformer(
- box, self, Transform.QUAD, quad, resample, fillcolor is None
- )
- else:
- im.__transformer(
- (0, 0) + size, self, method, data, resample, fillcolor is None
- )
-
- return im
-
- def __transformer(
- self, box, image, method, data, resample=Resampling.NEAREST, fill=1
- ):
- w = box[2] - box[0]
- h = box[3] - box[1]
-
- if method == Transform.AFFINE:
- data = data[:6]
-
- elif method == Transform.EXTENT:
- # convert extent to an affine transform
- x0, y0, x1, y1 = data
- xs = (x1 - x0) / w
- ys = (y1 - y0) / h
- method = Transform.AFFINE
- data = (xs, 0, x0, 0, ys, y0)
-
- elif method == Transform.PERSPECTIVE:
- data = data[:8]
-
- elif method == Transform.QUAD:
- # quadrilateral warp. data specifies the four corners
- # given as NW, SW, SE, and NE.
- nw = data[:2]
- sw = data[2:4]
- se = data[4:6]
- ne = data[6:8]
- x0, y0 = nw
- As = 1.0 / w
- At = 1.0 / h
- data = (
- x0,
- (ne[0] - x0) * As,
- (sw[0] - x0) * At,
- (se[0] - sw[0] - ne[0] + x0) * As * At,
- y0,
- (ne[1] - y0) * As,
- (sw[1] - y0) * At,
- (se[1] - sw[1] - ne[1] + y0) * As * At,
- )
-
- else:
- raise ValueError("unknown transformation method")
-
- if resample not in (
- Resampling.NEAREST,
- Resampling.BILINEAR,
- Resampling.BICUBIC,
- ):
- if resample in (Resampling.BOX, Resampling.HAMMING, Resampling.LANCZOS):
- message = {
- Resampling.BOX: "Image.Resampling.BOX",
- Resampling.HAMMING: "Image.Resampling.HAMMING",
- Resampling.LANCZOS: "Image.Resampling.LANCZOS",
- }[resample] + f" ({resample}) cannot be used."
- else:
- message = f"Unknown resampling filter ({resample})."
-
- filters = [
- f"{filter[1]} ({filter[0]})"
- for filter in (
- (Resampling.NEAREST, "Image.Resampling.NEAREST"),
- (Resampling.BILINEAR, "Image.Resampling.BILINEAR"),
- (Resampling.BICUBIC, "Image.Resampling.BICUBIC"),
- )
- ]
- raise ValueError(
- message + " Use " + ", ".join(filters[:-1]) + " or " + filters[-1]
- )
-
- image.load()
-
- self.load()
-
- if image.mode in ("1", "P"):
- resample = Resampling.NEAREST
-
- self.im.transform2(box, image.im, method, data, resample, fill)
-
- def transpose(self, method):
- """
- Transpose image (flip or rotate in 90 degree steps)
-
- :param method: One of :py:data:`Transpose.FLIP_LEFT_RIGHT`,
- :py:data:`Transpose.FLIP_TOP_BOTTOM`, :py:data:`Transpose.ROTATE_90`,
- :py:data:`Transpose.ROTATE_180`, :py:data:`Transpose.ROTATE_270`,
- :py:data:`Transpose.TRANSPOSE` or :py:data:`Transpose.TRANSVERSE`.
- :returns: Returns a flipped or rotated copy of this image.
- """
-
- self.load()
- return self._new(self.im.transpose(method))
-
- def effect_spread(self, distance):
- """
- Randomly spread pixels in an image.
-
- :param distance: Distance to spread pixels.
- """
- self.load()
- return self._new(self.im.effect_spread(distance))
-
- def toqimage(self):
- """Returns a QImage copy of this image"""
- from . import ImageQt
-
- if not ImageQt.qt_is_installed:
- raise ImportError("Qt bindings are not installed")
- return ImageQt.toqimage(self)
-
- def toqpixmap(self):
- """Returns a QPixmap copy of this image"""
- from . import ImageQt
-
- if not ImageQt.qt_is_installed:
- raise ImportError("Qt bindings are not installed")
- return ImageQt.toqpixmap(self)
-
-
-# --------------------------------------------------------------------
-# Abstract handlers.
-
-
-class ImagePointHandler:
- """
- Used as a mixin by point transforms
- (for use with :py:meth:`~PIL.Image.Image.point`)
- """
-
- pass
-
-
-class ImageTransformHandler:
- """
- Used as a mixin by geometry transforms
- (for use with :py:meth:`~PIL.Image.Image.transform`)
- """
-
- pass
-
-
-# --------------------------------------------------------------------
-# Factories
-
-#
-# Debugging
-
-
-def _wedge():
- """Create greyscale wedge (for debugging only)"""
-
- return Image()._new(core.wedge("L"))
-
-
-def _check_size(size):
- """
- Common check to enforce type and sanity check on size tuples
-
- :param size: Should be a 2 tuple of (width, height)
- :returns: True, or raises a ValueError
- """
-
- if not isinstance(size, (list, tuple)):
- raise ValueError("Size must be a tuple")
- if len(size) != 2:
- raise ValueError("Size must be a tuple of length 2")
- if size[0] < 0 or size[1] < 0:
- raise ValueError("Width and height must be >= 0")
-
- return True
-
-
-def new(mode, size, color=0):
- """
- Creates a new image with the given mode and size.
-
- :param mode: The mode to use for the new image. See:
- :ref:`concept-modes`.
- :param size: A 2-tuple, containing (width, height) in pixels.
- :param color: What color to use for the image. Default is black.
- If given, this should be a single integer or floating point value
- for single-band modes, and a tuple for multi-band modes (one value
- per band). When creating RGB images, you can also use color
- strings as supported by the ImageColor module. If the color is
- None, the image is not initialised.
- :returns: An :py:class:`~PIL.Image.Image` object.
- """
-
- _check_size(size)
-
- if color is None:
- # don't initialize
- return Image()._new(core.new(mode, size))
-
- if isinstance(color, str):
- # css3-style specifier
-
- from . import ImageColor
-
- color = ImageColor.getcolor(color, mode)
-
- im = Image()
- if mode == "P" and isinstance(color, (list, tuple)) and len(color) in [3, 4]:
- # RGB or RGBA value for a P image
- from . import ImagePalette
-
- im.palette = ImagePalette.ImagePalette()
- color = im.palette.getcolor(color)
- return im._new(core.fill(mode, size, color))
-
-
-def frombytes(mode, size, data, decoder_name="raw", *args):
- """
- Creates a copy of an image memory from pixel data in a buffer.
-
- In its simplest form, this function takes three arguments
- (mode, size, and unpacked pixel data).
-
- You can also use any pixel decoder supported by PIL. For more
- information on available decoders, see the section
- :ref:`Writing Your Own File Codec `.
-
- Note that this function decodes pixel data only, not entire images.
- If you have an entire image in a string, wrap it in a
- :py:class:`~io.BytesIO` object, and use :py:func:`~PIL.Image.open` to load
- it.
-
- :param mode: The image mode. See: :ref:`concept-modes`.
- :param size: The image size.
- :param data: A byte buffer containing raw data for the given mode.
- :param decoder_name: What decoder to use.
- :param args: Additional parameters for the given decoder.
- :returns: An :py:class:`~PIL.Image.Image` object.
- """
-
- _check_size(size)
-
- # may pass tuple instead of argument list
- if len(args) == 1 and isinstance(args[0], tuple):
- args = args[0]
-
- if decoder_name == "raw" and args == ():
- args = mode
-
- im = new(mode, size)
- im.frombytes(data, decoder_name, args)
- return im
-
-
-def frombuffer(mode, size, data, decoder_name="raw", *args):
- """
- Creates an image memory referencing pixel data in a byte buffer.
-
- This function is similar to :py:func:`~PIL.Image.frombytes`, but uses data
- in the byte buffer, where possible. This means that changes to the
- original buffer object are reflected in this image). Not all modes can
- share memory; supported modes include "L", "RGBX", "RGBA", and "CMYK".
-
- Note that this function decodes pixel data only, not entire images.
- If you have an entire image file in a string, wrap it in a
- :py:class:`~io.BytesIO` object, and use :py:func:`~PIL.Image.open` to load it.
-
- In the current version, the default parameters used for the "raw" decoder
- differs from that used for :py:func:`~PIL.Image.frombytes`. This is a
- bug, and will probably be fixed in a future release. The current release
- issues a warning if you do this; to disable the warning, you should provide
- the full set of parameters. See below for details.
-
- :param mode: The image mode. See: :ref:`concept-modes`.
- :param size: The image size.
- :param data: A bytes or other buffer object containing raw
- data for the given mode.
- :param decoder_name: What decoder to use.
- :param args: Additional parameters for the given decoder. For the
- default encoder ("raw"), it's recommended that you provide the
- full set of parameters::
-
- frombuffer(mode, size, data, "raw", mode, 0, 1)
-
- :returns: An :py:class:`~PIL.Image.Image` object.
-
- .. versionadded:: 1.1.4
- """
-
- _check_size(size)
-
- # may pass tuple instead of argument list
- if len(args) == 1 and isinstance(args[0], tuple):
- args = args[0]
-
- if decoder_name == "raw":
- if args == ():
- args = mode, 0, 1
- if args[0] in _MAPMODES:
- im = new(mode, (1, 1))
- im = im._new(core.map_buffer(data, size, decoder_name, 0, args))
- if mode == "P":
- from . import ImagePalette
-
- im.palette = ImagePalette.ImagePalette("RGB", im.im.getpalette("RGB"))
- im.readonly = 1
- return im
-
- return frombytes(mode, size, data, decoder_name, args)
-
-
-def fromarray(obj, mode=None):
- """
- Creates an image memory from an object exporting the array interface
- (using the buffer protocol).
-
- If ``obj`` is not contiguous, then the ``tobytes`` method is called
- and :py:func:`~PIL.Image.frombuffer` is used.
-
- If you have an image in NumPy::
-
- from PIL import Image
- import numpy as np
- im = Image.open("hopper.jpg")
- a = np.asarray(im)
-
- Then this can be used to convert it to a Pillow image::
-
- im = Image.fromarray(a)
-
- :param obj: Object with array interface
- :param mode: Optional mode to use when reading ``obj``. Will be determined from
- type if ``None``.
-
- This will not be used to convert the data after reading, but will be used to
- change how the data is read::
-
- from PIL import Image
- import numpy as np
- a = np.full((1, 1), 300)
- im = Image.fromarray(a, mode="L")
- im.getpixel((0, 0)) # 44
- im = Image.fromarray(a, mode="RGB")
- im.getpixel((0, 0)) # (44, 1, 0)
-
- See: :ref:`concept-modes` for general information about modes.
- :returns: An image object.
-
- .. versionadded:: 1.1.6
- """
- arr = obj.__array_interface__
- shape = arr["shape"]
- ndim = len(shape)
- strides = arr.get("strides", None)
- if mode is None:
- try:
- typekey = (1, 1) + shape[2:], arr["typestr"]
- except KeyError as e:
- raise TypeError("Cannot handle this data type") from e
- try:
- mode, rawmode = _fromarray_typemap[typekey]
- except KeyError as e:
- raise TypeError("Cannot handle this data type: %s, %s" % typekey) from e
- else:
- rawmode = mode
- if mode in ["1", "L", "I", "P", "F"]:
- ndmax = 2
- elif mode == "RGB":
- ndmax = 3
- else:
- ndmax = 4
- if ndim > ndmax:
- raise ValueError(f"Too many dimensions: {ndim} > {ndmax}.")
-
- size = 1 if ndim == 1 else shape[1], shape[0]
- if strides is not None:
- if hasattr(obj, "tobytes"):
- obj = obj.tobytes()
- else:
- obj = obj.tostring()
-
- return frombuffer(mode, size, obj, "raw", rawmode, 0, 1)
-
-
-def fromqimage(im):
- """Creates an image instance from a QImage image"""
- from . import ImageQt
-
- if not ImageQt.qt_is_installed:
- raise ImportError("Qt bindings are not installed")
- return ImageQt.fromqimage(im)
-
-
-def fromqpixmap(im):
- """Creates an image instance from a QPixmap image"""
- from . import ImageQt
-
- if not ImageQt.qt_is_installed:
- raise ImportError("Qt bindings are not installed")
- return ImageQt.fromqpixmap(im)
-
-
-_fromarray_typemap = {
- # (shape, typestr) => mode, rawmode
- # first two members of shape are set to one
- ((1, 1), "|b1"): ("1", "1;8"),
- ((1, 1), "|u1"): ("L", "L"),
- ((1, 1), "|i1"): ("I", "I;8"),
- ((1, 1), "u2"): ("I", "I;16B"),
- ((1, 1), "i2"): ("I", "I;16BS"),
- ((1, 1), "u4"): ("I", "I;32B"),
- ((1, 1), "i4"): ("I", "I;32BS"),
- ((1, 1), "f4"): ("F", "F;32BF"),
- ((1, 1), "f8"): ("F", "F;64BF"),
- ((1, 1, 2), "|u1"): ("LA", "LA"),
- ((1, 1, 3), "|u1"): ("RGB", "RGB"),
- ((1, 1, 4), "|u1"): ("RGBA", "RGBA"),
- # shortcuts:
- ((1, 1), _ENDIAN + "i4"): ("I", "I"),
- ((1, 1), _ENDIAN + "f4"): ("F", "F"),
-}
-
-
-def _decompression_bomb_check(size):
- if MAX_IMAGE_PIXELS is None:
- return
-
- pixels = size[0] * size[1]
-
- if pixels > 2 * MAX_IMAGE_PIXELS:
- raise DecompressionBombError(
- f"Image size ({pixels} pixels) exceeds limit of {2 * MAX_IMAGE_PIXELS} "
- "pixels, could be decompression bomb DOS attack."
- )
-
- if pixels > MAX_IMAGE_PIXELS:
- warnings.warn(
- f"Image size ({pixels} pixels) exceeds limit of {MAX_IMAGE_PIXELS} pixels, "
- "could be decompression bomb DOS attack.",
- DecompressionBombWarning,
- )
-
-
-def open(fp, mode="r", formats=None):
- """
- Opens and identifies the given image file.
-
- This is a lazy operation; this function identifies the file, but
- the file remains open and the actual image data is not read from
- the file until you try to process the data (or call the
- :py:meth:`~PIL.Image.Image.load` method). See
- :py:func:`~PIL.Image.new`. See :ref:`file-handling`.
-
- :param fp: A filename (string), pathlib.Path object or a file object.
- The file object must implement ``file.read``,
- ``file.seek``, and ``file.tell`` methods,
- and be opened in binary mode.
- :param mode: The mode. If given, this argument must be "r".
- :param formats: A list or tuple of formats to attempt to load the file in.
- This can be used to restrict the set of formats checked.
- Pass ``None`` to try all supported formats. You can print the set of
- available formats by running ``python3 -m PIL`` or using
- the :py:func:`PIL.features.pilinfo` function.
- :returns: An :py:class:`~PIL.Image.Image` object.
- :exception FileNotFoundError: If the file cannot be found.
- :exception PIL.UnidentifiedImageError: If the image cannot be opened and
- identified.
- :exception ValueError: If the ``mode`` is not "r", or if a ``StringIO``
- instance is used for ``fp``.
- :exception TypeError: If ``formats`` is not ``None``, a list or a tuple.
- """
-
- if mode != "r":
- raise ValueError(f"bad mode {repr(mode)}")
- elif isinstance(fp, io.StringIO):
- raise ValueError(
- "StringIO cannot be used to open an image. "
- "Binary data must be used instead."
- )
-
- if formats is None:
- formats = ID
- elif not isinstance(formats, (list, tuple)):
- raise TypeError("formats must be a list or tuple")
-
- exclusive_fp = False
- filename = ""
- if isinstance(fp, Path):
- filename = str(fp.resolve())
- elif is_path(fp):
- filename = fp
-
- if filename:
- fp = builtins.open(filename, "rb")
- exclusive_fp = True
-
- try:
- fp.seek(0)
- except (AttributeError, io.UnsupportedOperation):
- fp = io.BytesIO(fp.read())
- exclusive_fp = True
-
- prefix = fp.read(16)
-
- preinit()
-
- accept_warnings = []
-
- def _open_core(fp, filename, prefix, formats):
- for i in formats:
- i = i.upper()
- if i not in OPEN:
- init()
- try:
- factory, accept = OPEN[i]
- result = not accept or accept(prefix)
- if type(result) in [str, bytes]:
- accept_warnings.append(result)
- elif result:
- fp.seek(0)
- im = factory(fp, filename)
- _decompression_bomb_check(im.size)
- return im
- except (SyntaxError, IndexError, TypeError, struct.error):
- # Leave disabled by default, spams the logs with image
- # opening failures that are entirely expected.
- # logger.debug("", exc_info=True)
- continue
- except BaseException:
- if exclusive_fp:
- fp.close()
- raise
- return None
-
- im = _open_core(fp, filename, prefix, formats)
-
- if im is None:
- if init():
- im = _open_core(fp, filename, prefix, formats)
-
- if im:
- im._exclusive_fp = exclusive_fp
- return im
-
- if exclusive_fp:
- fp.close()
- for message in accept_warnings:
- warnings.warn(message)
- raise UnidentifiedImageError(
- "cannot identify image file %r" % (filename if filename else fp)
- )
-
-
-#
-# Image processing.
-
-
-def alpha_composite(im1, im2):
- """
- Alpha composite im2 over im1.
-
- :param im1: The first image. Must have mode RGBA.
- :param im2: The second image. Must have mode RGBA, and the same size as
- the first image.
- :returns: An :py:class:`~PIL.Image.Image` object.
- """
-
- im1.load()
- im2.load()
- return im1._new(core.alpha_composite(im1.im, im2.im))
-
-
-def blend(im1, im2, alpha):
- """
- Creates a new image by interpolating between two input images, using
- a constant alpha::
-
- out = image1 * (1.0 - alpha) + image2 * alpha
-
- :param im1: The first image.
- :param im2: The second image. Must have the same mode and size as
- the first image.
- :param alpha: The interpolation alpha factor. If alpha is 0.0, a
- copy of the first image is returned. If alpha is 1.0, a copy of
- the second image is returned. There are no restrictions on the
- alpha value. If necessary, the result is clipped to fit into
- the allowed output range.
- :returns: An :py:class:`~PIL.Image.Image` object.
- """
-
- im1.load()
- im2.load()
- return im1._new(core.blend(im1.im, im2.im, alpha))
-
-
-def composite(image1, image2, mask):
- """
- Create composite image by blending images using a transparency mask.
-
- :param image1: The first image.
- :param image2: The second image. Must have the same mode and
- size as the first image.
- :param mask: A mask image. This image can have mode
- "1", "L", or "RGBA", and must have the same size as the
- other two images.
- """
-
- image = image2.copy()
- image.paste(image1, None, mask)
- return image
-
-
-def eval(image, *args):
- """
- Applies the function (which should take one argument) to each pixel
- in the given image. If the image has more than one band, the same
- function is applied to each band. Note that the function is
- evaluated once for each possible pixel value, so you cannot use
- random components or other generators.
-
- :param image: The input image.
- :param function: A function object, taking one integer argument.
- :returns: An :py:class:`~PIL.Image.Image` object.
- """
-
- return image.point(args[0])
-
-
-def merge(mode, bands):
- """
- Merge a set of single band images into a new multiband image.
-
- :param mode: The mode to use for the output image. See:
- :ref:`concept-modes`.
- :param bands: A sequence containing one single-band image for
- each band in the output image. All bands must have the
- same size.
- :returns: An :py:class:`~PIL.Image.Image` object.
- """
-
- if getmodebands(mode) != len(bands) or "*" in mode:
- raise ValueError("wrong number of bands")
- for band in bands[1:]:
- if band.mode != getmodetype(mode):
- raise ValueError("mode mismatch")
- if band.size != bands[0].size:
- raise ValueError("size mismatch")
- for band in bands:
- band.load()
- return bands[0]._new(core.merge(mode, *[b.im for b in bands]))
-
-
-# --------------------------------------------------------------------
-# Plugin registry
-
-
-def register_open(id, factory, accept=None):
- """
- Register an image file plugin. This function should not be used
- in application code.
-
- :param id: An image format identifier.
- :param factory: An image file factory method.
- :param accept: An optional function that can be used to quickly
- reject images having another format.
- """
- id = id.upper()
- ID.append(id)
- OPEN[id] = factory, accept
-
-
-def register_mime(id, mimetype):
- """
- Registers an image MIME type. This function should not be used
- in application code.
-
- :param id: An image format identifier.
- :param mimetype: The image MIME type for this format.
- """
- MIME[id.upper()] = mimetype
-
-
-def register_save(id, driver):
- """
- Registers an image save function. This function should not be
- used in application code.
-
- :param id: An image format identifier.
- :param driver: A function to save images in this format.
- """
- SAVE[id.upper()] = driver
-
-
-def register_save_all(id, driver):
- """
- Registers an image function to save all the frames
- of a multiframe format. This function should not be
- used in application code.
-
- :param id: An image format identifier.
- :param driver: A function to save images in this format.
- """
- SAVE_ALL[id.upper()] = driver
-
-
-def register_extension(id, extension):
- """
- Registers an image extension. This function should not be
- used in application code.
-
- :param id: An image format identifier.
- :param extension: An extension used for this format.
- """
- EXTENSION[extension.lower()] = id.upper()
-
-
-def register_extensions(id, extensions):
- """
- Registers image extensions. This function should not be
- used in application code.
-
- :param id: An image format identifier.
- :param extensions: A list of extensions used for this format.
- """
- for extension in extensions:
- register_extension(id, extension)
-
-
-def registered_extensions():
- """
- Returns a dictionary containing all file extensions belonging
- to registered plugins
- """
- if not EXTENSION:
- init()
- return EXTENSION
-
-
-def register_decoder(name, decoder):
- """
- Registers an image decoder. This function should not be
- used in application code.
-
- :param name: The name of the decoder
- :param decoder: A callable(mode, args) that returns an
- ImageFile.PyDecoder object
-
- .. versionadded:: 4.1.0
- """
- DECODERS[name] = decoder
-
-
-def register_encoder(name, encoder):
- """
- Registers an image encoder. This function should not be
- used in application code.
-
- :param name: The name of the encoder
- :param encoder: A callable(mode, args) that returns an
- ImageFile.PyEncoder object
-
- .. versionadded:: 4.1.0
- """
- ENCODERS[name] = encoder
-
-
-# --------------------------------------------------------------------
-# Simple display support.
-
-
-def _show(image, **options):
- from . import ImageShow
-
- ImageShow.show(image, **options)
-
-
-# --------------------------------------------------------------------
-# Effects
-
-
-def effect_mandelbrot(size, extent, quality):
- """
- Generate a Mandelbrot set covering the given extent.
-
- :param size: The requested size in pixels, as a 2-tuple:
- (width, height).
- :param extent: The extent to cover, as a 4-tuple:
- (x0, y0, x1, y1).
- :param quality: Quality.
- """
- return Image()._new(core.effect_mandelbrot(size, extent, quality))
-
-
-def effect_noise(size, sigma):
- """
- Generate Gaussian noise centered around 128.
-
- :param size: The requested size in pixels, as a 2-tuple:
- (width, height).
- :param sigma: Standard deviation of noise.
- """
- return Image()._new(core.effect_noise(size, sigma))
-
-
-def linear_gradient(mode):
- """
- Generate 256x256 linear gradient from black to white, top to bottom.
-
- :param mode: Input mode.
- """
- return Image()._new(core.linear_gradient(mode))
-
-
-def radial_gradient(mode):
- """
- Generate 256x256 radial gradient from black to white, centre to edge.
-
- :param mode: Input mode.
- """
- return Image()._new(core.radial_gradient(mode))
-
-
-# --------------------------------------------------------------------
-# Resources
-
-
-def _apply_env_variables(env=None):
- if env is None:
- env = os.environ
-
- for var_name, setter in [
- ("PILLOW_ALIGNMENT", core.set_alignment),
- ("PILLOW_BLOCK_SIZE", core.set_block_size),
- ("PILLOW_BLOCKS_MAX", core.set_blocks_max),
- ]:
- if var_name not in env:
- continue
-
- var = env[var_name].lower()
-
- units = 1
- for postfix, mul in [("k", 1024), ("m", 1024 * 1024)]:
- if var.endswith(postfix):
- units = mul
- var = var[: -len(postfix)]
-
- try:
- var = int(var) * units
- except ValueError:
- warnings.warn(f"{var_name} is not int")
- continue
-
- try:
- setter(var)
- except ValueError as e:
- warnings.warn(f"{var_name}: {e}")
-
-
-_apply_env_variables()
-atexit.register(core.clear_cache)
-
-
-class Exif(MutableMapping):
- endian = None
- bigtiff = False
-
- def __init__(self):
- self._data = {}
- self._ifds = {}
- self._info = None
- self._loaded_exif = None
-
- def _fixup(self, value):
- try:
- if len(value) == 1 and isinstance(value, tuple):
- return value[0]
- except Exception:
- pass
- return value
-
- def _fixup_dict(self, src_dict):
- # Helper function
- # returns a dict with any single item tuples/lists as individual values
- return {k: self._fixup(v) for k, v in src_dict.items()}
-
- def _get_ifd_dict(self, offset):
- try:
- # an offset pointer to the location of the nested embedded IFD.
- # It should be a long, but may be corrupted.
- self.fp.seek(offset)
- except (KeyError, TypeError):
- pass
- else:
- from . import TiffImagePlugin
-
- info = TiffImagePlugin.ImageFileDirectory_v2(self.head)
- info.load(self.fp)
- return self._fixup_dict(info)
-
- def _get_head(self):
- version = b"\x2B" if self.bigtiff else b"\x2A"
- if self.endian == "<":
- head = b"II" + version + b"\x00" + o32le(8)
- else:
- head = b"MM\x00" + version + o32be(8)
- if self.bigtiff:
- head += o32le(8) if self.endian == "<" else o32be(8)
- head += b"\x00\x00\x00\x00"
- return head
-
- def load(self, data):
- # Extract EXIF information. This is highly experimental,
- # and is likely to be replaced with something better in a future
- # version.
-
- # The EXIF record consists of a TIFF file embedded in a JPEG
- # application marker (!).
- if data == self._loaded_exif:
- return
- self._loaded_exif = data
- self._data.clear()
- self._ifds.clear()
- if data and data.startswith(b"Exif\x00\x00"):
- data = data[6:]
- if not data:
- self._info = None
- return
-
- self.fp = io.BytesIO(data)
- self.head = self.fp.read(8)
- # process dictionary
- from . import TiffImagePlugin
-
- self._info = TiffImagePlugin.ImageFileDirectory_v2(self.head)
- self.endian = self._info._endian
- self.fp.seek(self._info.next)
- self._info.load(self.fp)
-
- def load_from_fp(self, fp, offset=None):
- self._loaded_exif = None
- self._data.clear()
- self._ifds.clear()
-
- # process dictionary
- from . import TiffImagePlugin
-
- self.fp = fp
- if offset is not None:
- self.head = self._get_head()
- else:
- self.head = self.fp.read(8)
- self._info = TiffImagePlugin.ImageFileDirectory_v2(self.head)
- if self.endian is None:
- self.endian = self._info._endian
- if offset is None:
- offset = self._info.next
- self.fp.seek(offset)
- self._info.load(self.fp)
-
- def _get_merged_dict(self):
- merged_dict = dict(self)
-
- # get EXIF extension
- if 0x8769 in self:
- ifd = self._get_ifd_dict(self[0x8769])
- if ifd:
- merged_dict.update(ifd)
-
- # GPS
- if 0x8825 in self:
- merged_dict[0x8825] = self._get_ifd_dict(self[0x8825])
-
- return merged_dict
-
- def tobytes(self, offset=8):
- from . import TiffImagePlugin
-
- head = self._get_head()
- ifd = TiffImagePlugin.ImageFileDirectory_v2(ifh=head)
- for tag, value in self.items():
- if tag in [0x8769, 0x8225, 0x8825] and not isinstance(value, dict):
- value = self.get_ifd(tag)
- if (
- tag == 0x8769
- and 0xA005 in value
- and not isinstance(value[0xA005], dict)
- ):
- value = value.copy()
- value[0xA005] = self.get_ifd(0xA005)
- ifd[tag] = value
- return b"Exif\x00\x00" + head + ifd.tobytes(offset)
-
- def get_ifd(self, tag):
- if tag not in self._ifds:
- if tag in [0x8769, 0x8825]:
- # exif, gpsinfo
- if tag in self:
- self._ifds[tag] = self._get_ifd_dict(self[tag])
- elif tag in [0xA005, 0x927C]:
- # interop, makernote
- if 0x8769 not in self._ifds:
- self.get_ifd(0x8769)
- tag_data = self._ifds[0x8769][tag]
- if tag == 0x927C:
- # makernote
- from .TiffImagePlugin import ImageFileDirectory_v2
-
- if tag_data[:8] == b"FUJIFILM":
- ifd_offset = i32le(tag_data, 8)
- ifd_data = tag_data[ifd_offset:]
-
- makernote = {}
- for i in range(0, struct.unpack(" 4:
- (offset,) = struct.unpack("H", tag_data[:2])[0]):
- ifd_tag, typ, count, data = struct.unpack(
- ">HHL4s", tag_data[i * 12 + 2 : (i + 1) * 12 + 2]
- )
- if ifd_tag == 0x1101:
- # CameraInfo
- (offset,) = struct.unpack(">L", data)
- self.fp.seek(offset)
-
- camerainfo = {"ModelID": self.fp.read(4)}
-
- self.fp.read(4)
- # Seconds since 2000
- camerainfo["TimeStamp"] = i32le(self.fp.read(12))
-
- self.fp.read(4)
- camerainfo["InternalSerialNumber"] = self.fp.read(4)
-
- self.fp.read(12)
- parallax = self.fp.read(4)
- handler = ImageFileDirectory_v2._load_dispatch[
- TiffTags.FLOAT
- ][1]
- camerainfo["Parallax"] = handler(
- ImageFileDirectory_v2(), parallax, False
- )
-
- self.fp.read(4)
- camerainfo["Category"] = self.fp.read(2)
-
- makernote = {0x1101: dict(self._fixup_dict(camerainfo))}
- self._ifds[tag] = makernote
- else:
- # interop
- self._ifds[tag] = self._get_ifd_dict(tag_data)
- return self._ifds.get(tag, {})
-
- def __str__(self):
- if self._info is not None:
- # Load all keys into self._data
- for tag in self._info.keys():
- self[tag]
-
- return str(self._data)
-
- def __len__(self):
- keys = set(self._data)
- if self._info is not None:
- keys.update(self._info)
- return len(keys)
-
- def __getitem__(self, tag):
- if self._info is not None and tag not in self._data and tag in self._info:
- self._data[tag] = self._fixup(self._info[tag])
- del self._info[tag]
- return self._data[tag]
-
- def __contains__(self, tag):
- return tag in self._data or (self._info is not None and tag in self._info)
-
- def __setitem__(self, tag, value):
- if self._info is not None and tag in self._info:
- del self._info[tag]
- self._data[tag] = value
-
- def __delitem__(self, tag):
- if self._info is not None and tag in self._info:
- del self._info[tag]
- else:
- del self._data[tag]
-
- def __iter__(self):
- keys = set(self._data)
- if self._info is not None:
- keys.update(self._info)
- return iter(keys)
diff --git a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/altair/examples/us_population_pyramid_over_time.py b/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/altair/examples/us_population_pyramid_over_time.py
deleted file mode 100644
index 624db71d5421a00400113467a76c7a23b4f25c9e..0000000000000000000000000000000000000000
--- a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/altair/examples/us_population_pyramid_over_time.py
+++ /dev/null
@@ -1,55 +0,0 @@
-'''
-US Population Pyramid Over Time
-===============================
-A population pyramid shows the distribution of age groups within a population.
-It uses a slider widget that is bound to the year to visualize the age
-distribution over time.
-'''
-# category: case studies
-import altair as alt
-from vega_datasets import data
-
-source = data.population.url
-
-slider = alt.binding_range(min=1850, max=2000, step=10)
-select_year = alt.selection_single(name='year', fields=['year'],
- bind=slider, init={'year': 2000})
-
-base = alt.Chart(source).add_selection(
- select_year
-).transform_filter(
- select_year
-).transform_calculate(
- gender=alt.expr.if_(alt.datum.sex == 1, 'Male', 'Female')
-).properties(
- width=250
-)
-
-
-color_scale = alt.Scale(domain=['Male', 'Female'],
- range=['#1f77b4', '#e377c2'])
-
-left = base.transform_filter(
- alt.datum.gender == 'Female'
-).encode(
- y=alt.Y('age:O', axis=None),
- x=alt.X('sum(people):Q',
- title='population',
- sort=alt.SortOrder('descending')),
- color=alt.Color('gender:N', scale=color_scale, legend=None)
-).mark_bar().properties(title='Female')
-
-middle = base.encode(
- y=alt.Y('age:O', axis=None),
- text=alt.Text('age:Q'),
-).mark_text().properties(width=20)
-
-right = base.transform_filter(
- alt.datum.gender == 'Male'
-).encode(
- y=alt.Y('age:O', axis=None),
- x=alt.X('sum(people):Q', title='population'),
- color=alt.Color('gender:N', scale=color_scale, legend=None)
-).mark_bar().properties(title='Male')
-
-alt.concat(left, middle, right, spacing=5)
\ No newline at end of file
diff --git a/spaces/asteph/harrywang-pokemon-lora/app.py b/spaces/asteph/harrywang-pokemon-lora/app.py
deleted file mode 100644
index c9837672ddc0c4e17dd4cf655c786fd4ef92317d..0000000000000000000000000000000000000000
--- a/spaces/asteph/harrywang-pokemon-lora/app.py
+++ /dev/null
@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/harrywang/pokemon-lora").launch()
\ No newline at end of file
diff --git a/spaces/avivdm1/AutoGPT/autogpt/json_utils/__init__.py b/spaces/avivdm1/AutoGPT/autogpt/json_utils/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/avivdm1/AutoGPT/run_continuous.bat b/spaces/avivdm1/AutoGPT/run_continuous.bat
deleted file mode 100644
index 812aa01c1c5506c452665610c0e9e83a17c426f2..0000000000000000000000000000000000000000
--- a/spaces/avivdm1/AutoGPT/run_continuous.bat
+++ /dev/null
@@ -1,3 +0,0 @@
-@echo off
-set argument=--continuous
-call run.bat %argument%
diff --git a/spaces/awacke1/2-LiveASR/app.py b/spaces/awacke1/2-LiveASR/app.py
deleted file mode 100644
index b19b04136d7b2ab879c98b3d38b872a735352641..0000000000000000000000000000000000000000
--- a/spaces/awacke1/2-LiveASR/app.py
+++ /dev/null
@@ -1,138 +0,0 @@
-import gradio as gr
-import torch
-import time
-import librosa
-import soundfile
-import nemo.collections.asr as nemo_asr
-import tempfile
-import os
-import uuid
-
-from transformers import BlenderbotTokenizer, BlenderbotForConditionalGeneration
-import torch
-
-# PersistDataset -----
-import os
-import csv
-import gradio as gr
-from gradio import inputs, outputs
-import huggingface_hub
-from huggingface_hub import Repository, hf_hub_download, upload_file
-from datetime import datetime
-
-# ---------------------------------------------
-# Dataset and Token links - change awacke1 to your own HF id, and add a HF_TOKEN copy to your repo for write permissions
-# This should allow you to save your results to your own Dataset hosted on HF.
-
-DATASET_REPO_URL = "https://huggingface.co/datasets/awacke1/ASRLive.csv"
-DATASET_REPO_ID = "awacke1/ASRLive.csv"
-DATA_FILENAME = "ASRLive.csv"
-DATA_FILE = os.path.join("data", DATA_FILENAME)
-HF_TOKEN = os.environ.get("HF_TOKEN")
-
-PersistToDataset = False
-#PersistToDataset = True # uncomment to save inference output to ASRLive.csv dataset
-
-if PersistToDataset:
- try:
- hf_hub_download(
- repo_id=DATASET_REPO_ID,
- filename=DATA_FILENAME,
- cache_dir=DATA_DIRNAME,
- force_filename=DATA_FILENAME
- )
- except:
- print("file not found")
- repo = Repository(
- local_dir="data", clone_from=DATASET_REPO_URL, use_auth_token=HF_TOKEN
- )
-
-def store_message(name: str, message: str):
- if name and message:
- with open(DATA_FILE, "a") as csvfile:
- writer = csv.DictWriter(csvfile, fieldnames=["name", "message", "time"])
- writer.writerow(
- {"name": name.strip(), "message": message.strip(), "time": str(datetime.now())}
- )
- # uncomment line below to begin saving -
- commit_url = repo.push_to_hub()
- ret = ""
- with open(DATA_FILE, "r") as csvfile:
- reader = csv.DictReader(csvfile)
-
- for row in reader:
- ret += row
- ret += "\r\n"
- return ret
-
-# main -------------------------
-mname = "facebook/blenderbot-400M-distill"
-model = BlenderbotForConditionalGeneration.from_pretrained(mname)
-tokenizer = BlenderbotTokenizer.from_pretrained(mname)
-
-def take_last_tokens(inputs, note_history, history):
- filterTokenCount = 128 # filter last 128 tokens
- if inputs['input_ids'].shape[1] > filterTokenCount:
- inputs['input_ids'] = torch.tensor([inputs['input_ids'][0][-filterTokenCount:].tolist()])
- inputs['attention_mask'] = torch.tensor([inputs['attention_mask'][0][-filterTokenCount:].tolist()])
- note_history = [' '.join(note_history[0].split(' ')[2:])]
- history = history[1:]
- return inputs, note_history, history
-
-def add_note_to_history(note, note_history):
- note_history.append(note)
- note_history = ' '.join(note_history)
- return [note_history]
-
-
-
-SAMPLE_RATE = 16000
-model = nemo_asr.models.EncDecRNNTBPEModel.from_pretrained("nvidia/stt_en_conformer_transducer_xlarge")
-model.change_decoding_strategy(None)
-model.eval()
-
-def process_audio_file(file):
- data, sr = librosa.load(file)
- if sr != SAMPLE_RATE:
- data = librosa.resample(data, orig_sr=sr, target_sr=SAMPLE_RATE)
- data = librosa.to_mono(data)
- return data
-
-
-def transcribe(audio, state = ""):
- if state is None:
- state = ""
- audio_data = process_audio_file(audio)
- with tempfile.TemporaryDirectory() as tmpdir:
- audio_path = os.path.join(tmpdir, f'audio_{uuid.uuid4()}.wav')
- soundfile.write(audio_path, audio_data, SAMPLE_RATE)
- transcriptions = model.transcribe([audio_path])
- if type(transcriptions) == tuple and len(transcriptions) == 2:
- transcriptions = transcriptions[0]
- transcriptions = transcriptions[0]
-
- if PersistToDataset:
- ret = store_message(transcriptions, state) # Save to dataset - uncomment to store into a dataset - hint you will need your HF_TOKEN
- state = state + transcriptions + " " + ret
- else:
- state = state + transcriptions
- return state, state
-
-gr.Interface(
- fn=transcribe,
- inputs=[
- gr.Audio(source="microphone", type='filepath', streaming=True),
- "state",
- ],
- outputs=[
- "textbox",
- "state"
- ],
- layout="horizontal",
- theme="huggingface",
- title="🗣️ASR-Gradio-Live🧠💾",
- description=f"Live Automatic Speech Recognition (ASR).",
- allow_flagging='never',
- live=True,
- article=f"Result💾 Dataset: [{DATASET_REPO_URL}]({DATASET_REPO_URL})"
-).launch(debug=True)
diff --git a/spaces/awacke1/ASR-openai-whisper-base/app.py b/spaces/awacke1/ASR-openai-whisper-base/app.py
deleted file mode 100644
index ddedf9ed0e7c4809c5dea4b633a52d5975f8f4c4..0000000000000000000000000000000000000000
--- a/spaces/awacke1/ASR-openai-whisper-base/app.py
+++ /dev/null
@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/openai/whisper-base").launch()
\ No newline at end of file
diff --git a/spaces/awacke1/FirestorePersistence/app.py b/spaces/awacke1/FirestorePersistence/app.py
deleted file mode 100644
index 25d864111289f672836321b3e8228edb498673cf..0000000000000000000000000000000000000000
--- a/spaces/awacke1/FirestorePersistence/app.py
+++ /dev/null
@@ -1,85 +0,0 @@
-import streamlit as st
-import firebase_admin
-from firebase_admin import credentials
-from firebase_admin import firestore
-from datetime import datetime
-
-now = datetime.now() # current date and time
-year = now.strftime("%Y")
-st.write("year:", year)
-month = now.strftime("%m")
-st.write("month:", month)
-day = now.strftime("%d")
-st.write("day:", day)
-time = now.strftime("%H:%M:%S")
-st.write("time:", time)
-date_time = now.strftime("%m/%d/%Y, %H:%M:%S")
-st.write("date and time:",date_time)
-
-@st.experimental_singleton
-def get_db_firestore():
- cred = credentials.Certificate('test.json')
- firebase_admin.initialize_app(cred, {'projectId': u'clinical-nlp-b9117',})
- db = firestore.client()
- return db
-
-#add data to the beastie with a generic reusable upsert function
-def upsert(collection, document, firefield, first, last, born):
- doc_ref = db.collection(collection).document(document)
- doc_ref.set({u'firefield': firefield, u'first': first, u'last': last, u'born': born
-})
-
-#read data back in firecollection
-def selectCollection(collection):
- users_ref = db.collection(collection)
- docs = users_ref.stream()
- for doc in docs:
- st.write(f'{doc.id} => {doc.to_dict()}')
-
-def selectCollectionDocument(collection, document):
- doc_ref = db.collection(collection).document(document)
- doc = doc_ref.get()
- st.write("The id is: ", doc.id)
- st.write("The contents are: ", doc.to_dict())
-
-#add data to the beastie with a generic reusable upsert function
-def upsertoftheminute(collection, document, firefield, first, last, born):
- date_time = now.strftime("%m/%d/%Y, %H:%M")
- doc_ref = db.collection(collection).document(document)
- doc_ref.set({u'firefield': firefield, u'first': first, u'last': last, u'born': date_time,})
-
-
-st.write("singleton stateful connection to cloud firestore")
-st.write(u"spin up some awesome 🤯 - episodic and semantic memory 🧠 for AI - here we come")
-db = get_db_firestore()
-
-# perceptual system processing agent that can store model
-upsert(u'firecollection', u'firedocument', u'users1', u'Ada', u'Lovelace', 1815)
-upsert(u'firecollection', u'firedocument', u'users2', u'Aaron', u'Wacker', 1971)
-upsert(u'firecollection1', u'firedocument3', u'users1', u'2022 - AI, Cognitive and Neuroscience to Assist and Augment Behavioral and Medical Health', u'https://www.youtube.com/watch?v=lvh3g7eszVQ&list=PLHgX2IExbFouJoqEr8JMF5MbZSbyC91-L', 2022)
-upsert(u'firecollection2', u'firedocument2', u'users2', u'2022 - AI art sci-fi movies and stories 🎭🎞️🍿 by Aaron Wacker 🎬 🧠 🎨', u'https://www.youtube.com/playlist?list=PLHgX2IExbFotUCOCZgpj-5HZBzXOpFMYc', 2022)
-upsert(u'firecollection3', u'firedocument3', u'users3', u'😶🌫️ 🤯Engineering Consciousness🧠 😶🌫️', u'https://youtu.be/rIpUf-Vy2JA?list=PLHgX2IExbFouJoqEr8JMF5MbZSbyC91-L&t=3622', 2022)
-upsert(u'firecollection4', u'firedocument4', u'users4', u'🧠🌳Yggdrasil🌳🧠', u'https://github.com/AaronCWacker/Yggdrasil', 2022)
-
-# its all stored here: https://console.firebase.google.com/u/0/project/clinical-nlp-b9117/firestore/data/~2FStreamlitSpaces
-
-
-selectCollection(u'firecollection')
-selectCollection(u'firecollection1')
-selectCollection(u'firecollection2')
-selectCollection(u'firecollection3')
-selectCollection(u'firecollection4')
-selectCollectionDocument(u"firecollection", u"firedocument")
-selectCollectionDocument(u"firecollection1", u"firedocument3")
-selectCollectionDocument(u"firecollection3", u"firedocument3")
-
-
-# from https://huggingface.co/spaces/awacke1/RealTimeVoiceASR
-selectCollectionDocument(u"ASRCollection", u"ASRDocument")
-
-
-upsert(u'firecollection4', u'firedocument4', u'users4', u'🧠🌳Yggdrasil🌳🧠', u'https://github.com/AaronCWacker/Yggdrasil', 2022)
-
-# intent - upsert at granularity of minute an aggregate document representing fields used in recent activity to replay shared state memory events
-upsertoftheminute(u'TimeSeries', u'DocumentofMinute', u'TestUser1', u'🧠🌳Yggdrasil🌳🧠', u'https://huggingface.co/spaces/awacke1/FirestorePersistence', 2022)
-selectCollectionDocument(u"TimeSeries", u"DocumentofMinute")
\ No newline at end of file
diff --git a/spaces/awacke1/NLPStoryWriterWithMemory/app.py b/spaces/awacke1/NLPStoryWriterWithMemory/app.py
deleted file mode 100644
index 463e122620440fcafd00fc0582d1b908ab8de7fd..0000000000000000000000000000000000000000
--- a/spaces/awacke1/NLPStoryWriterWithMemory/app.py
+++ /dev/null
@@ -1,103 +0,0 @@
-import gradio as gr
-import os
-
-# PersistDataset -----
-import os
-import csv
-import gradio as gr
-from gradio import inputs, outputs
-import huggingface_hub
-from huggingface_hub import Repository, hf_hub_download, upload_file
-from datetime import datetime
-
-# created new dataset as awacke1/MindfulStory.csv
-DATASET_REPO_URL = "https://huggingface.co/datasets/awacke1/MindfulStory.csv"
-DATASET_REPO_ID = "awacke1/MindfulStory.csv"
-DATA_FILENAME = "MindfulStory.csv"
-DATA_FILE = os.path.join("data", DATA_FILENAME)
-HF_TOKEN = os.environ.get("HF_TOKEN")
-# Download dataset repo using hub download
-try:
- hf_hub_download(
- repo_id=DATASET_REPO_ID,
- filename=DATA_FILENAME,
- cache_dir=DATA_DIRNAME,
- force_filename=DATA_FILENAME
- )
-except:
- print("file not found")
-
-def AIMemory(title: str, story: str):
- if title and story:
- with open(DATA_FILE, "a") as csvfile:
- writer = csv.DictWriter(csvfile, fieldnames=["title", "story", "time"])
- writer.writerow({"title": title, "story": story, "time": str(datetime.now())})
- commit_url = repo.push_to_hub()
- return ""
-
-
-# Set up cloned dataset from repo for operations
-repo = Repository(
- local_dir="data", clone_from=DATASET_REPO_URL, use_auth_token=HF_TOKEN
-)
-
-generator1 = gr.Interface.load("huggingface/gpt2-large", api_key=HF_TOKEN)
-generator2 = gr.Interface.load("huggingface/EleutherAI/gpt-neo-2.7B", api_key=HF_TOKEN)
-generator3 = gr.Interface.load("huggingface/EleutherAI/gpt-j-6B", api_key=HF_TOKEN)
-
-def calculator(intro, operator, outro):
- if operator == "add":
- output = generator2(intro) + generator3(outro)
- title = intro + " " + outro
- saved = AIMemory(title, output)
- return output
- elif operator == "subtract":
- output = generator2(outro) + generator3(intro)
- title = outro + " " + intro
- saved = AIMemory(title, output)
- output = output.replace(intro, "").replace(outro, "")
- return output
- elif operator == "multiply":
- output = generator1(intro) + generator2(outro) + generator3(intro)
- title = intro + " " + outro + " " + intro
- saved = AIMemory(title, output)
- return output
- elif operator == "divide":
- output = generator1(outro) + generator2(intro) + generator3(outro)
- title = outro + " " + intro + " " + outro
- saved = AIMemory(title, output)
- output = output.replace(intro, "").replace(outro, "")
- return output
-
-#with open('Mindfulness.txt', 'r') as file:
-# context = file.read()
-#contextBox = gr.Textbox(lines=3, default=context, label="Story starter")
-
-examples = [
- ["Music and art make me feel", "add", "Path to Health and Happiness"],
- ["Feel better each day when you awake by", "add", "Mental Body Scan"],
- ["Feel better physically by", "add", "Stretch, Calm, Breath"],
- ["Practicing mindfulness each day", "add", "Walk Feel"],
- ["Be happier by", "add", "Brain gamification"],
- ["Meditation can improve health", "add", "Deep Breaths"],
- ["Spending time outdoors", "add", "Find Joy"],
- ["Stress is relieved by quieting your mind, getting exercise and time with nature", "add", "Relieve Pain"],
- ["Break the cycle of stress and anxiety", "add", "Yoga and Meditation"],
- ["Feel calm in stressful situations", "add", "Neocortex Tools and Techniques"],
- ["Deal with work pressure", "add", "Strengthen Attention"],
- ["Learn to reduce feelings of overwhelmed", "add", "Easy Daily Activities"]
-]
-
-demo = gr.Interface(
- calculator,
- [
- "text",
- gr.Radio(["add", "subtract", "multiply", "divide"]),
- "text"
- ],
- "text",
- examples=examples,
- article="Saved story memory dataset: https://huggingface.co/datasets/awacke1/MindfulStory.csv with available models to use from text gen: https://huggingface.co/models?pipeline_tag=text-generation&sort=downloads",
- live=True,
-)
-demo.launch()
\ No newline at end of file
diff --git a/spaces/banana-projects/web3d/node_modules/three/examples/js/libs/dat.gui.min.js b/spaces/banana-projects/web3d/node_modules/three/examples/js/libs/dat.gui.min.js
deleted file mode 100644
index 5b69be5aae03edb7be84df6398fb28e66c331086..0000000000000000000000000000000000000000
--- a/spaces/banana-projects/web3d/node_modules/three/examples/js/libs/dat.gui.min.js
+++ /dev/null
@@ -1,14 +0,0 @@
-/**
- * dat-gui JavaScript Controller Library
- * https://github.com/dataarts/dat.gui
- *
- * Copyright 2016 Data Arts Team, Google Creative Lab
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- */
-!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.dat=t():e.dat=t()}(this,function(){return function(e){function t(o){if(n[o])return n[o].exports;var i=n[o]={exports:{},id:o,loaded:!1};return e[o].call(i.exports,i,i.exports,t),i.loaded=!0,i.exports}var n={};return t.m=e,t.c=n,t.p="",t(0)}([function(e,t,n){"use strict";function o(e){return e&&e.__esModule?e:{"default":e}}var i=n(1),r=o(i);e.exports=r["default"]},function(e,t,n){"use strict";function o(e){return e&&e.__esModule?e:{"default":e}}t.__esModule=!0;var i=n(2),r=o(i),a=n(6),l=o(a),s=n(3),u=o(s),d=n(7),c=o(d),f=n(8),_=o(f),p=n(10),h=o(p),m=n(11),b=o(m),g=n(12),v=o(g),y=n(13),w=o(y),x=n(14),E=o(x),C=n(15),A=o(C),S=n(16),k=o(S),O=n(9),T=o(O),R=n(17),L=o(R);t["default"]={color:{Color:r["default"],math:l["default"],interpret:u["default"]},controllers:{Controller:c["default"],BooleanController:_["default"],OptionController:h["default"],StringController:b["default"],NumberController:v["default"],NumberControllerBox:w["default"],NumberControllerSlider:E["default"],FunctionController:A["default"],ColorController:k["default"]},dom:{dom:T["default"]},gui:{GUI:L["default"]},GUI:L["default"]}},function(e,t,n){"use strict";function o(e){return e&&e.__esModule?e:{"default":e}}function i(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function r(e,t,n){Object.defineProperty(e,t,{get:function(){return"RGB"===this.__state.space?this.__state[t]:(h.recalculateRGB(this,t,n),this.__state[t])},set:function(e){"RGB"!==this.__state.space&&(h.recalculateRGB(this,t,n),this.__state.space="RGB"),this.__state[t]=e}})}function a(e,t){Object.defineProperty(e,t,{get:function(){return"HSV"===this.__state.space?this.__state[t]:(h.recalculateHSV(this),this.__state[t])},set:function(e){"HSV"!==this.__state.space&&(h.recalculateHSV(this),this.__state.space="HSV"),this.__state[t]=e}})}t.__esModule=!0;var l=n(3),s=o(l),u=n(6),d=o(u),c=n(4),f=o(c),_=n(5),p=o(_),h=function(){function e(){if(i(this,e),this.__state=s["default"].apply(this,arguments),this.__state===!1)throw new Error("Failed to interpret color arguments");this.__state.a=this.__state.a||1}return e.prototype.toString=function(){return(0,f["default"])(this)},e.prototype.toHexString=function(){return(0,f["default"])(this,!0)},e.prototype.toOriginal=function(){return this.__state.conversion.write(this)},e}();h.recalculateRGB=function(e,t,n){if("HEX"===e.__state.space)e.__state[t]=d["default"].component_from_hex(e.__state.hex,n);else{if("HSV"!==e.__state.space)throw new Error("Corrupted color state");p["default"].extend(e.__state,d["default"].hsv_to_rgb(e.__state.h,e.__state.s,e.__state.v))}},h.recalculateHSV=function(e){var t=d["default"].rgb_to_hsv(e.r,e.g,e.b);p["default"].extend(e.__state,{s:t.s,v:t.v}),p["default"].isNaN(t.h)?p["default"].isUndefined(e.__state.h)&&(e.__state.h=0):e.__state.h=t.h},h.COMPONENTS=["r","g","b","h","s","v","hex","a"],r(h.prototype,"r",2),r(h.prototype,"g",1),r(h.prototype,"b",0),a(h.prototype,"h"),a(h.prototype,"s"),a(h.prototype,"v"),Object.defineProperty(h.prototype,"a",{get:function(){return this.__state.a},set:function(e){this.__state.a=e}}),Object.defineProperty(h.prototype,"hex",{get:function(){return"HEX"!==!this.__state.space&&(this.__state.hex=d["default"].rgb_to_hex(this.r,this.g,this.b)),this.__state.hex},set:function(e){this.__state.space="HEX",this.__state.hex=e}}),t["default"]=h},function(e,t,n){"use strict";function o(e){return e&&e.__esModule?e:{"default":e}}t.__esModule=!0;var i=n(4),r=o(i),a=n(5),l=o(a),s=[{litmus:l["default"].isString,conversions:{THREE_CHAR_HEX:{read:function(e){var t=e.match(/^#([A-F0-9])([A-F0-9])([A-F0-9])$/i);return null!==t&&{space:"HEX",hex:parseInt("0x"+t[1].toString()+t[1].toString()+t[2].toString()+t[2].toString()+t[3].toString()+t[3].toString(),0)}},write:r["default"]},SIX_CHAR_HEX:{read:function(e){var t=e.match(/^#([A-F0-9]{6})$/i);return null!==t&&{space:"HEX",hex:parseInt("0x"+t[1].toString(),0)}},write:r["default"]},CSS_RGB:{read:function(e){var t=e.match(/^rgb\(\s*(.+)\s*,\s*(.+)\s*,\s*(.+)\s*\)/);return null!==t&&{space:"RGB",r:parseFloat(t[1]),g:parseFloat(t[2]),b:parseFloat(t[3])}},write:r["default"]},CSS_RGBA:{read:function(e){var t=e.match(/^rgba\(\s*(.+)\s*,\s*(.+)\s*,\s*(.+)\s*,\s*(.+)\s*\)/);return null!==t&&{space:"RGB",r:parseFloat(t[1]),g:parseFloat(t[2]),b:parseFloat(t[3]),a:parseFloat(t[4])}},write:r["default"]}}},{litmus:l["default"].isNumber,conversions:{HEX:{read:function(e){return{space:"HEX",hex:e,conversionName:"HEX"}},write:function(e){return e.hex}}}},{litmus:l["default"].isArray,conversions:{RGB_ARRAY:{read:function(e){return 3===e.length&&{space:"RGB",r:e[0],g:e[1],b:e[2]}},write:function(e){return[e.r,e.g,e.b]}},RGBA_ARRAY:{read:function(e){return 4===e.length&&{space:"RGB",r:e[0],g:e[1],b:e[2],a:e[3]}},write:function(e){return[e.r,e.g,e.b,e.a]}}}},{litmus:l["default"].isObject,conversions:{RGBA_OBJ:{read:function(e){return!!(l["default"].isNumber(e.r)&&l["default"].isNumber(e.g)&&l["default"].isNumber(e.b)&&l["default"].isNumber(e.a))&&{space:"RGB",r:e.r,g:e.g,b:e.b,a:e.a}},write:function(e){return{r:e.r,g:e.g,b:e.b,a:e.a}}},RGB_OBJ:{read:function(e){return!!(l["default"].isNumber(e.r)&&l["default"].isNumber(e.g)&&l["default"].isNumber(e.b))&&{space:"RGB",r:e.r,g:e.g,b:e.b}},write:function(e){return{r:e.r,g:e.g,b:e.b}}},HSVA_OBJ:{read:function(e){return!!(l["default"].isNumber(e.h)&&l["default"].isNumber(e.s)&&l["default"].isNumber(e.v)&&l["default"].isNumber(e.a))&&{space:"HSV",h:e.h,s:e.s,v:e.v,a:e.a}},write:function(e){return{h:e.h,s:e.s,v:e.v,a:e.a}}},HSV_OBJ:{read:function(e){return!!(l["default"].isNumber(e.h)&&l["default"].isNumber(e.s)&&l["default"].isNumber(e.v))&&{space:"HSV",h:e.h,s:e.s,v:e.v}},write:function(e){return{h:e.h,s:e.s,v:e.v}}}}}],u=void 0,d=void 0,c=function(){d=!1;var e=arguments.length>1?l["default"].toArray(arguments):arguments[0];return l["default"].each(s,function(t){if(t.litmus(e))return l["default"].each(t.conversions,function(t,n){if(u=t.read(e),d===!1&&u!==!1)return d=u,u.conversionName=n,u.conversion=t,l["default"].BREAK}),l["default"].BREAK}),d};t["default"]=c},function(e,t){"use strict";t.__esModule=!0,t["default"]=function(e,t){var n=e.__state.conversionName.toString(),o=Math.round(e.r),i=Math.round(e.g),r=Math.round(e.b),a=e.a,l=Math.round(e.h),s=e.s.toFixed(1),u=e.v.toFixed(1);if(t||"THREE_CHAR_HEX"===n||"SIX_CHAR_HEX"===n){for(var d=e.hex.toString(16);d.length<6;)d="0"+d;return"#"+d}return"CSS_RGB"===n?"rgb("+o+","+i+","+r+")":"CSS_RGBA"===n?"rgba("+o+","+i+","+r+","+a+")":"HEX"===n?"0x"+e.hex.toString(16):"RGB_ARRAY"===n?"["+o+","+i+","+r+"]":"RGBA_ARRAY"===n?"["+o+","+i+","+r+","+a+"]":"RGB_OBJ"===n?"{r:"+o+",g:"+i+",b:"+r+"}":"RGBA_OBJ"===n?"{r:"+o+",g:"+i+",b:"+r+",a:"+a+"}":"HSV_OBJ"===n?"{h:"+l+",s:"+s+",v:"+u+"}":"HSVA_OBJ"===n?"{h:"+l+",s:"+s+",v:"+u+",a:"+a+"}":"unknown format"}},function(e,t){"use strict";t.__esModule=!0;var n=Array.prototype.forEach,o=Array.prototype.slice,i={BREAK:{},extend:function(e){return this.each(o.call(arguments,1),function(t){var n=this.isObject(t)?Object.keys(t):[];n.forEach(function(n){this.isUndefined(t[n])||(e[n]=t[n])}.bind(this))},this),e},defaults:function(e){return this.each(o.call(arguments,1),function(t){var n=this.isObject(t)?Object.keys(t):[];n.forEach(function(n){this.isUndefined(e[n])&&(e[n]=t[n])}.bind(this))},this),e},compose:function(){var e=o.call(arguments);return function(){for(var t=o.call(arguments),n=e.length-1;n>=0;n--)t=[e[n].apply(this,t)];return t[0]}},each:function(e,t,o){if(e)if(n&&e.forEach&&e.forEach===n)e.forEach(t,o);else if(e.length===e.length+0){var i=void 0,r=void 0;for(i=0,r=e.length;i>8*t&255},hex_with_component:function(e,t,o){return o<<(n=8*t)|e&~(255<-1?t.length-t.indexOf(".")-1:0}t.__esModule=!0;var s=n(7),u=o(s),d=n(5),c=o(d),f=function(e){function t(n,o,a){i(this,t);var s=r(this,e.call(this,n,o)),u=a||{};return s.__min=u.min,s.__max=u.max,s.__step=u.step,c["default"].isUndefined(s.__step)?0===s.initialValue?s.__impliedStep=1:s.__impliedStep=Math.pow(10,Math.floor(Math.log(Math.abs(s.initialValue))/Math.LN10))/10:s.__impliedStep=s.__step,s.__precision=l(s.__impliedStep),s}return a(t,e),t.prototype.setValue=function(t){var n=t;return void 0!==this.__min&&nthis.__max&&(n=this.__max),void 0!==this.__step&&n%this.__step!==0&&(n=Math.round(n/this.__step)*this.__step),e.prototype.setValue.call(this,n)},t.prototype.min=function(e){return this.__min=e,this},t.prototype.max=function(e){return this.__max=e,this},t.prototype.step=function(e){return this.__step=e,this.__impliedStep=e,this.__precision=l(e),this},t}(u["default"]);t["default"]=f},function(e,t,n){"use strict";function o(e){return e&&e.__esModule?e:{"default":e}}function i(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function r(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function a(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}function l(e,t){var n=Math.pow(10,t);return Math.round(e*n)/n}t.__esModule=!0;var s=n(12),u=o(s),d=n(9),c=o(d),f=n(5),_=o(f),p=function(e){function t(n,o,a){function l(){var e=parseFloat(m.__input.value);_["default"].isNaN(e)||m.setValue(e)}function s(){m.__onFinishChange&&m.__onFinishChange.call(m,m.getValue())}function u(){s()}function d(e){var t=b-e.clientY;m.setValue(m.getValue()+t*m.__impliedStep),b=e.clientY}function f(){c["default"].unbind(window,"mousemove",d),c["default"].unbind(window,"mouseup",f),s()}function p(e){c["default"].bind(window,"mousemove",d),c["default"].bind(window,"mouseup",f),b=e.clientY}i(this,t);var h=r(this,e.call(this,n,o,a));h.__truncationSuspended=!1;var m=h,b=void 0;return h.__input=document.createElement("input"),h.__input.setAttribute("type","text"),c["default"].bind(h.__input,"change",l),c["default"].bind(h.__input,"blur",u),c["default"].bind(h.__input,"mousedown",p),c["default"].bind(h.__input,"keydown",function(e){13===e.keyCode&&(m.__truncationSuspended=!0,this.blur(),m.__truncationSuspended=!1,s())}),h.updateDisplay(),h.domElement.appendChild(h.__input),h}return a(t,e),t.prototype.updateDisplay=function(){return this.__input.value=this.__truncationSuspended?this.getValue():l(this.getValue(),this.__precision),e.prototype.updateDisplay.call(this)},t}(u["default"]);t["default"]=p},function(e,t,n){"use strict";function o(e){return e&&e.__esModule?e:{"default":e}}function i(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function r(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function a(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}function l(e,t,n,o,i){return o+(i-o)*((e-t)/(n-t))}t.__esModule=!0;var s=n(12),u=o(s),d=n(9),c=o(d),f=function(e){function t(n,o,a,s,u){function d(e){document.activeElement.blur(),c["default"].bind(window,"mousemove",f),c["default"].bind(window,"mouseup",_),f(e)}function f(e){e.preventDefault();var t=h.__background.getBoundingClientRect();return h.setValue(l(e.clientX,t.left,t.right,h.__min,h.__max)),!1}function _(){c["default"].unbind(window,"mousemove",f),c["default"].unbind(window,"mouseup",_),h.__onFinishChange&&h.__onFinishChange.call(h,h.getValue())}i(this,t);var p=r(this,e.call(this,n,o,{min:a,max:s,step:u})),h=p;return p.__background=document.createElement("div"),p.__foreground=document.createElement("div"),c["default"].bind(p.__background,"mousedown",d),c["default"].addClass(p.__background,"slider"),c["default"].addClass(p.__foreground,"slider-fg"),p.updateDisplay(),p.__background.appendChild(p.__foreground),p.domElement.appendChild(p.__background),p}return a(t,e),t.prototype.updateDisplay=function(){var t=(this.getValue()-this.__min)/(this.__max-this.__min);return this.__foreground.style.width=100*t+"%",e.prototype.updateDisplay.call(this)},t}(u["default"]);t["default"]=f},function(e,t,n){"use strict";function o(e){return e&&e.__esModule?e:{"default":e}}function i(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function r(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function a(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}t.__esModule=!0;var l=n(7),s=o(l),u=n(9),d=o(u),c=function(e){function t(n,o,a){i(this,t);var l=r(this,e.call(this,n,o)),s=l;return l.__button=document.createElement("div"),l.__button.innerHTML=void 0===a?"Fire":a,d["default"].bind(l.__button,"click",function(e){return e.preventDefault(),s.fire(),!1}),d["default"].addClass(l.__button,"button"),l.domElement.appendChild(l.__button),l}return a(t,e),t.prototype.fire=function(){this.__onChange&&this.__onChange.call(this),this.getValue().call(this.object),this.__onFinishChange&&this.__onFinishChange.call(this,this.getValue())},t}(s["default"]);t["default"]=c},function(e,t,n){"use strict";function o(e){return e&&e.__esModule?e:{"default":e}}function i(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function r(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function a(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}function l(e,t,n,o){e.style.background="",g["default"].each(y,function(i){e.style.cssText+="background: "+i+"linear-gradient("+t+", "+n+" 0%, "+o+" 100%); "})}function s(e){e.style.background="",e.style.cssText+="background: -moz-linear-gradient(top, #ff0000 0%, #ff00ff 17%, #0000ff 34%, #00ffff 50%, #00ff00 67%, #ffff00 84%, #ff0000 100%);",e.style.cssText+="background: -webkit-linear-gradient(top, #ff0000 0%,#ff00ff 17%,#0000ff 34%,#00ffff 50%,#00ff00 67%,#ffff00 84%,#ff0000 100%);",e.style.cssText+="background: -o-linear-gradient(top, #ff0000 0%,#ff00ff 17%,#0000ff 34%,#00ffff 50%,#00ff00 67%,#ffff00 84%,#ff0000 100%);",e.style.cssText+="background: -ms-linear-gradient(top, #ff0000 0%,#ff00ff 17%,#0000ff 34%,#00ffff 50%,#00ff00 67%,#ffff00 84%,#ff0000 100%);",e.style.cssText+="background: linear-gradient(top, #ff0000 0%,#ff00ff 17%,#0000ff 34%,#00ffff 50%,#00ff00 67%,#ffff00 84%,#ff0000 100%);"}t.__esModule=!0;var u=n(7),d=o(u),c=n(9),f=o(c),_=n(2),p=o(_),h=n(3),m=o(h),b=n(5),g=o(b),v=function(e){function t(n,o){function a(e){h(e),f["default"].bind(window,"mousemove",h),f["default"].bind(window,"mouseup",u)}function u(){f["default"].unbind(window,"mousemove",h),f["default"].unbind(window,"mouseup",u),_()}function d(){var e=(0,m["default"])(this.value);e!==!1?(y.__color.__state=e,y.setValue(y.__color.toOriginal())):this.value=y.__color.toString()}function c(){f["default"].unbind(window,"mousemove",b),f["default"].unbind(window,"mouseup",c),_()}function _(){y.__onFinishChange&&y.__onFinishChange.call(y,y.__color.toOriginal())}function h(e){e.preventDefault();var t=y.__saturation_field.getBoundingClientRect(),n=(e.clientX-t.left)/(t.right-t.left),o=1-(e.clientY-t.top)/(t.bottom-t.top);return o>1?o=1:o<0&&(o=0),n>1?n=1:n<0&&(n=0),y.__color.v=o,y.__color.s=n,y.setValue(y.__color.toOriginal()),!1}function b(e){e.preventDefault();var t=y.__hue_field.getBoundingClientRect(),n=1-(e.clientY-t.top)/(t.bottom-t.top);return n>1?n=1:n<0&&(n=0),y.__color.h=360*n,y.setValue(y.__color.toOriginal()),!1}i(this,t);var v=r(this,e.call(this,n,o));v.__color=new p["default"](v.getValue()),v.__temp=new p["default"](0);var y=v;v.domElement=document.createElement("div"),f["default"].makeSelectable(v.domElement,!1),v.__selector=document.createElement("div"),v.__selector.className="selector",v.__saturation_field=document.createElement("div"),v.__saturation_field.className="saturation-field",v.__field_knob=document.createElement("div"),v.__field_knob.className="field-knob",v.__field_knob_border="2px solid ",v.__hue_knob=document.createElement("div"),v.__hue_knob.className="hue-knob",v.__hue_field=document.createElement("div"),v.__hue_field.className="hue-field",v.__input=document.createElement("input"),v.__input.type="text",v.__input_textShadow="0 1px 1px ",f["default"].bind(v.__input,"keydown",function(e){13===e.keyCode&&d.call(this)}),f["default"].bind(v.__input,"blur",d),f["default"].bind(v.__selector,"mousedown",function(){f["default"].addClass(this,"drag").bind(window,"mouseup",function(){f["default"].removeClass(y.__selector,"drag")})});var w=document.createElement("div");return g["default"].extend(v.__selector.style,{width:"122px",height:"102px",padding:"3px",backgroundColor:"#222",boxShadow:"0px 1px 3px rgba(0,0,0,0.3)"}),g["default"].extend(v.__field_knob.style,{position:"absolute",width:"12px",height:"12px",border:v.__field_knob_border+(v.__color.v<.5?"#fff":"#000"),boxShadow:"0px 1px 3px rgba(0,0,0,0.5)",borderRadius:"12px",zIndex:1}),g["default"].extend(v.__hue_knob.style,{position:"absolute",width:"15px",height:"2px",borderRight:"4px solid #fff",zIndex:1}),g["default"].extend(v.__saturation_field.style,{width:"100px",height:"100px",border:"1px solid #555",marginRight:"3px",display:"inline-block",cursor:"pointer"}),g["default"].extend(w.style,{width:"100%",height:"100%",background:"none"}),l(w,"top","rgba(0,0,0,0)","#000"),g["default"].extend(v.__hue_field.style,{width:"15px",height:"100px",border:"1px solid #555",cursor:"ns-resize",position:"absolute",top:"3px",right:"3px"}),s(v.__hue_field),g["default"].extend(v.__input.style,{outline:"none",textAlign:"center",color:"#fff",border:0,fontWeight:"bold",textShadow:v.__input_textShadow+"rgba(0,0,0,0.7)"}),f["default"].bind(v.__saturation_field,"mousedown",a),f["default"].bind(v.__field_knob,"mousedown",a),f["default"].bind(v.__hue_field,"mousedown",function(e){b(e),f["default"].bind(window,"mousemove",b),f["default"].bind(window,"mouseup",c)}),v.__saturation_field.appendChild(w),v.__selector.appendChild(v.__field_knob),v.__selector.appendChild(v.__saturation_field),v.__selector.appendChild(v.__hue_field),v.__hue_field.appendChild(v.__hue_knob),v.domElement.appendChild(v.__input),v.domElement.appendChild(v.__selector),v.updateDisplay(),v}return a(t,e),t.prototype.updateDisplay=function(){var e=(0,m["default"])(this.getValue());if(e!==!1){var t=!1;g["default"].each(p["default"].COMPONENTS,function(n){if(!g["default"].isUndefined(e[n])&&!g["default"].isUndefined(this.__color.__state[n])&&e[n]!==this.__color.__state[n])return t=!0,{}},this),t&&g["default"].extend(this.__color.__state,e)}g["default"].extend(this.__temp.__state,this.__color.__state),this.__temp.a=1;var n=this.__color.v<.5||this.__color.s>.5?255:0,o=255-n;g["default"].extend(this.__field_knob.style,{marginLeft:100*this.__color.s-7+"px",marginTop:100*(1-this.__color.v)-7+"px",backgroundColor:this.__temp.toHexString(),border:this.__field_knob_border+"rgb("+n+","+n+","+n+")"}),this.__hue_knob.style.marginTop=100*(1-this.__color.h/360)+"px",this.__temp.s=1,this.__temp.v=1,l(this.__saturation_field,"left","#fff",this.__temp.toHexString()),this.__input.value=this.__color.toString(),g["default"].extend(this.__input.style,{backgroundColor:this.__color.toHexString(),color:"rgb("+n+","+n+","+n+")",textShadow:this.__input_textShadow+"rgba("+o+","+o+","+o+",.7)"})},t}(d["default"]),y=["-moz-","-o-","-webkit-","-ms-",""];t["default"]=v},function(e,t,n){"use strict";function o(e){return e&&e.__esModule?e:{"default":e}}function i(e,t,n){var o=document.createElement("li");return t&&o.appendChild(t),n?e.__ul.insertBefore(o,n):e.__ul.appendChild(o),e.onResize(),o}function r(e,t){var n=e.__preset_select[e.__preset_select.selectedIndex];t?n.innerHTML=n.value+"*":n.innerHTML=n.value}function a(e,t,n){if(n.__li=t,n.__gui=e,U["default"].extend(n,{options:function(t){if(arguments.length>1){var o=n.__li.nextElementSibling;return n.remove(),s(e,n.object,n.property,{before:o,factoryArgs:[U["default"].toArray(arguments)]})}if(U["default"].isArray(t)||U["default"].isObject(t)){var i=n.__li.nextElementSibling;return n.remove(),s(e,n.object,n.property,{before:i,factoryArgs:[t]})}},name:function(e){return n.__li.firstElementChild.firstElementChild.innerHTML=e,n},listen:function(){return n.__gui.listen(n),n},remove:function(){
-return n.__gui.remove(n),n}}),n instanceof B["default"])!function(){var e=new N["default"](n.object,n.property,{min:n.__min,max:n.__max,step:n.__step});U["default"].each(["updateDisplay","onChange","onFinishChange","step"],function(t){var o=n[t],i=e[t];n[t]=e[t]=function(){var t=Array.prototype.slice.call(arguments);return i.apply(e,t),o.apply(n,t)}}),z["default"].addClass(t,"has-slider"),n.domElement.insertBefore(e.domElement,n.domElement.firstElementChild)}();else if(n instanceof N["default"]){var o=function(t){if(U["default"].isNumber(n.__min)&&U["default"].isNumber(n.__max)){var o=n.__li.firstElementChild.firstElementChild.innerHTML,i=n.__gui.__listening.indexOf(n)>-1;n.remove();var r=s(e,n.object,n.property,{before:n.__li.nextElementSibling,factoryArgs:[n.__min,n.__max,n.__step]});return r.name(o),i&&r.listen(),r}return t};n.min=U["default"].compose(o,n.min),n.max=U["default"].compose(o,n.max)}else n instanceof O["default"]?(z["default"].bind(t,"click",function(){z["default"].fakeEvent(n.__checkbox,"click")}),z["default"].bind(n.__checkbox,"click",function(e){e.stopPropagation()})):n instanceof R["default"]?(z["default"].bind(t,"click",function(){z["default"].fakeEvent(n.__button,"click")}),z["default"].bind(t,"mouseover",function(){z["default"].addClass(n.__button,"hover")}),z["default"].bind(t,"mouseout",function(){z["default"].removeClass(n.__button,"hover")})):n instanceof j["default"]&&(z["default"].addClass(t,"color"),n.updateDisplay=U["default"].compose(function(e){return t.style.borderLeftColor=n.__color.toString(),e},n.updateDisplay),n.updateDisplay());n.setValue=U["default"].compose(function(t){return e.getRoot().__preset_select&&n.isModified()&&r(e.getRoot(),!0),t},n.setValue)}function l(e,t){var n=e.getRoot(),o=n.__rememberedObjects.indexOf(t.object);if(o!==-1){var i=n.__rememberedObjectIndecesToControllers[o];if(void 0===i&&(i={},n.__rememberedObjectIndecesToControllers[o]=i),i[t.property]=t,n.load&&n.load.remembered){var r=n.load.remembered,a=void 0;if(r[e.preset])a=r[e.preset];else{if(!r[Q])return;a=r[Q]}if(a[o]&&void 0!==a[o][t.property]){var l=a[o][t.property];t.initialValue=l,t.setValue(l)}}}}function s(e,t,n,o){if(void 0===t[n])throw new Error('Object "'+t+'" has no property "'+n+'"');var r=void 0;if(o.color)r=new j["default"](t,n);else{var s=[t,n].concat(o.factoryArgs);r=C["default"].apply(e,s)}o.before instanceof S["default"]&&(o.before=o.before.__li),l(e,r),z["default"].addClass(r.domElement,"c");var u=document.createElement("span");z["default"].addClass(u,"property-name"),u.innerHTML=r.property;var d=document.createElement("div");d.appendChild(u),d.appendChild(r.domElement);var c=i(e,d,o.before);return z["default"].addClass(c,oe.CLASS_CONTROLLER_ROW),r instanceof j["default"]?z["default"].addClass(c,"color"):z["default"].addClass(c,g(r.getValue())),a(e,c,r),e.__controllers.push(r),r}function u(e,t){return document.location.href+"."+t}function d(e,t,n){var o=document.createElement("option");o.innerHTML=t,o.value=t,e.__preset_select.appendChild(o),n&&(e.__preset_select.selectedIndex=e.__preset_select.length-1)}function c(e,t){t.style.display=e.useLocalStorage?"block":"none"}function f(e){var t=e.__save_row=document.createElement("li");z["default"].addClass(e.domElement,"has-save"),e.__ul.insertBefore(t,e.__ul.firstChild),z["default"].addClass(t,"save-row");var n=document.createElement("span");n.innerHTML=" ",z["default"].addClass(n,"button gears");var o=document.createElement("span");o.innerHTML="Save",z["default"].addClass(o,"button"),z["default"].addClass(o,"save");var i=document.createElement("span");i.innerHTML="New",z["default"].addClass(i,"button"),z["default"].addClass(i,"save-as");var r=document.createElement("span");r.innerHTML="Revert",z["default"].addClass(r,"button"),z["default"].addClass(r,"revert");var a=e.__preset_select=document.createElement("select");e.load&&e.load.remembered?U["default"].each(e.load.remembered,function(t,n){d(e,n,n===e.preset)}):d(e,Q,!1),z["default"].bind(a,"change",function(){for(var t=0;t0&&(e.preset=this.preset,e.remembered||(e.remembered={}),e.remembered[this.preset]=h(this)),e.folders={},U["default"].each(this.__folders,function(t,n){e.folders[n]=t.getSaveObject()}),e},save:function(){this.load.remembered||(this.load.remembered={}),this.load.remembered[this.preset]=h(this),r(this,!1),this.saveToLocalStorageIfPossible()},saveAs:function(e){this.load.remembered||(this.load.remembered={},this.load.remembered[Q]=h(this,!0)),this.load.remembered[e]=h(this),this.preset=e,d(this,e,!0),this.saveToLocalStorageIfPossible()},revert:function(e){U["default"].each(this.__controllers,function(t){this.getRoot().load.remembered?l(e||this.getRoot(),t):t.setValue(t.initialValue),t.__onFinishChange&&t.__onFinishChange.call(t,t.getValue())},this),U["default"].each(this.__folders,function(e){e.revert(e)}),e||r(this.getRoot(),!1)},listen:function(e){var t=0===this.__listening.length;this.__listening.push(e),t&&b(this.__listening)},updateDisplay:function(){U["default"].each(this.__controllers,function(e){e.updateDisplay()}),U["default"].each(this.__folders,function(e){e.updateDisplay()})}}),e.exports=oe},function(e,t){"use strict";e.exports={load:function(e,t){var n=t||document,o=n.createElement("link");o.type="text/css",o.rel="stylesheet",o.href=e,n.getElementsByTagName("head")[0].appendChild(o)},inject:function(e,t){var n=t||document,o=document.createElement("style");o.type="text/css",o.innerHTML=e;var i=n.getElementsByTagName("head")[0];try{i.appendChild(o)}catch(r){}}}},function(e,t){e.exports=" Here's the new load parameter for your GUI's constructor: Automatically save values to localStorage on exit. The values saved to localStorage will override those passed to dat.GUI's constructor. This makes it easier to work incrementally, but localStorage is fragile, and your friends may not see the same values you do. "},function(e,t,n){"use strict";function o(e){return e&&e.__esModule?e:{"default":e}}t.__esModule=!0;var i=n(10),r=o(i),a=n(13),l=o(a),s=n(14),u=o(s),d=n(11),c=o(d),f=n(15),_=o(f),p=n(8),h=o(p),m=n(5),b=o(m),g=function(e,t){var n=e[t];return b["default"].isArray(arguments[2])||b["default"].isObject(arguments[2])?new r["default"](e,t,arguments[2]):b["default"].isNumber(n)?b["default"].isNumber(arguments[2])&&b["default"].isNumber(arguments[3])?b["default"].isNumber(arguments[4])?new u["default"](e,t,arguments[2],arguments[3],arguments[4]):new u["default"](e,t,arguments[2],arguments[3]):b["default"].isNumber(arguments[4])?new l["default"](e,t,{min:arguments[2],max:arguments[3],step:arguments[4]}):new l["default"](e,t,{min:arguments[2],max:arguments[3]}):b["default"].isString(n)?new c["default"](e,t):b["default"].isFunction(n)?new _["default"](e,t,""):b["default"].isBoolean(n)?new h["default"](e,t):null};t["default"]=g},function(e,t){"use strict";function n(e){setTimeout(e,1e3/60)}t.__esModule=!0,t["default"]=window.requestAnimationFrame||window.webkitRequestAnimationFrame||window.mozRequestAnimationFrame||window.oRequestAnimationFrame||window.msRequestAnimationFrame||n},function(e,t,n){"use strict";function o(e){return e&&e.__esModule?e:{"default":e}}function i(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}t.__esModule=!0;var r=n(9),a=o(r),l=n(5),s=o(l),u=function(){function e(){i(this,e),this.backgroundElement=document.createElement("div"),s["default"].extend(this.backgroundElement.style,{backgroundColor:"rgba(0,0,0,0.8)",top:0,left:0,display:"none",zIndex:"1000",opacity:0,WebkitTransition:"opacity 0.2s linear",transition:"opacity 0.2s linear"}),a["default"].makeFullscreen(this.backgroundElement),this.backgroundElement.style.position="fixed",this.domElement=document.createElement("div"),s["default"].extend(this.domElement.style,{position:"fixed",display:"none",zIndex:"1001",opacity:0,WebkitTransition:"-webkit-transform 0.2s ease-out, opacity 0.2s linear",transition:"transform 0.2s ease-out, opacity 0.2s linear"}),document.body.appendChild(this.backgroundElement),document.body.appendChild(this.domElement);var t=this;a["default"].bind(this.backgroundElement,"click",function(){t.hide()})}return e.prototype.show=function(){var e=this;this.backgroundElement.style.display="block",this.domElement.style.display="block",this.domElement.style.opacity=0,this.domElement.style.webkitTransform="scale(1.1)",this.layout(),s["default"].defer(function(){e.backgroundElement.style.opacity=1,e.domElement.style.opacity=1,e.domElement.style.webkitTransform="scale(1)"})},e.prototype.hide=function t(){var e=this,t=function n(){e.domElement.style.display="none",e.backgroundElement.style.display="none",a["default"].unbind(e.domElement,"webkitTransitionEnd",n),a["default"].unbind(e.domElement,"transitionend",n),a["default"].unbind(e.domElement,"oTransitionEnd",n)};a["default"].bind(this.domElement,"webkitTransitionEnd",t),a["default"].bind(this.domElement,"transitionend",t),a["default"].bind(this.domElement,"oTransitionEnd",t),this.backgroundElement.style.opacity=0,this.domElement.style.opacity=0,this.domElement.style.webkitTransform="scale(1.1)"},e.prototype.layout=function(){this.domElement.style.left=window.innerWidth/2-a["default"].getWidth(this.domElement)/2+"px",this.domElement.style.top=window.innerHeight/2-a["default"].getHeight(this.domElement)/2+"px"},e}();t["default"]=u},function(e,t,n){t=e.exports=n(24)(),t.push([e.id,".dg ul{list-style:none;margin:0;padding:0;width:100%;clear:both}.dg.ac{position:fixed;top:0;left:0;right:0;height:0;z-index:0}.dg:not(.ac) .main{overflow:hidden}.dg.main{-webkit-transition:opacity .1s linear;transition:opacity .1s linear}.dg.main.taller-than-window{overflow-y:auto}.dg.main.taller-than-window .close-button{opacity:1;margin-top:-1px;border-top:1px solid #2c2c2c}.dg.main ul.closed .close-button{opacity:1!important}.dg.main .close-button.drag,.dg.main:hover .close-button{opacity:1}.dg.main .close-button{-webkit-transition:opacity .1s linear;transition:opacity .1s linear;border:0;position:absolute;line-height:19px;height:20px;cursor:pointer;text-align:center;background-color:#000}.dg.main .close-button:hover{background-color:#111}.dg.a{float:right;margin-right:15px;overflow-x:hidden}.dg.a.has-save>ul{margin-top:27px}.dg.a.has-save>ul.closed{margin-top:0}.dg.a .save-row{position:fixed;top:0;z-index:1002}.dg li{-webkit-transition:height .1s ease-out;transition:height .1s ease-out}.dg li:not(.folder){cursor:auto;height:27px;line-height:27px;overflow:hidden;padding:0 4px 0 5px}.dg li.folder{padding:0;border-left:4px solid transparent}.dg li.title{cursor:pointer;margin-left:-4px}.dg .closed li:not(.title),.dg .closed ul li,.dg .closed ul li>*{height:0;overflow:hidden;border:0}.dg .cr{clear:both;padding-left:3px;height:27px}.dg .property-name{cursor:default;float:left;clear:left;width:40%;overflow:hidden;text-overflow:ellipsis}.dg .c{float:left;width:60%}.dg .c input[type=text]{border:0;margin-top:4px;padding:3px;width:100%;float:right}.dg .has-slider input[type=text]{width:30%;margin-left:0}.dg .slider{float:left;width:66%;margin-left:-5px;margin-right:0;height:19px;margin-top:4px}.dg .slider-fg{height:100%}.dg .c input[type=checkbox]{margin-top:9px}.dg .c select{margin-top:5px}.dg .cr.boolean,.dg .cr.boolean *,.dg .cr.function,.dg .cr.function *,.dg .cr.function .property-name{cursor:pointer}.dg .selector{display:none;position:absolute;margin-left:-9px;margin-top:23px;z-index:10}.dg .c:hover .selector,.dg .selector.drag{display:block}.dg li.save-row{padding:0}.dg li.save-row .button{display:inline-block;padding:0 6px}.dg.dialogue{background-color:#222;width:460px;padding:15px;font-size:13px;line-height:15px}#dg-new-constructor{padding:10px;color:#222;font-family:Monaco,monospace;font-size:10px;border:0;resize:none;box-shadow:inset 1px 1px 1px #888;word-wrap:break-word;margin:12px 0;display:block;width:440px;overflow-y:scroll;height:100px;position:relative}#dg-local-explain{display:none;font-size:11px;line-height:17px;border-radius:3px;background-color:#333;padding:8px;margin-top:10px}#dg-local-explain code{font-size:10px}#dat-gui-save-locally{display:none}.dg{color:#eee;font:11px Lucida Grande,sans-serif;text-shadow:0 -1px 0 #111}.dg.main::-webkit-scrollbar{width:5px;background:#1a1a1a}.dg.main::-webkit-scrollbar-corner{height:0;display:none}.dg.main::-webkit-scrollbar-thumb{border-radius:5px;background:#676767}.dg li:not(.folder){background:#1a1a1a;border-bottom:1px solid #2c2c2c}.dg li.save-row{line-height:25px;background:#dad5cb;border:0}.dg li.save-row select{margin-left:5px;width:108px}.dg li.save-row .button{margin-left:5px;margin-top:1px;border-radius:2px;font-size:9px;line-height:7px;padding:4px 4px 5px;background:#c5bdad;color:#fff;text-shadow:0 1px 0 #b0a58f;box-shadow:0 -1px 0 #b0a58f;cursor:pointer}.dg li.save-row .button.gears{background:#c5bdad url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAsAAAANCAYAAAB/9ZQ7AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAQJJREFUeNpiYKAU/P//PwGIC/ApCABiBSAW+I8AClAcgKxQ4T9hoMAEUrxx2QSGN6+egDX+/vWT4e7N82AMYoPAx/evwWoYoSYbACX2s7KxCxzcsezDh3evFoDEBYTEEqycggWAzA9AuUSQQgeYPa9fPv6/YWm/Acx5IPb7ty/fw+QZblw67vDs8R0YHyQhgObx+yAJkBqmG5dPPDh1aPOGR/eugW0G4vlIoTIfyFcA+QekhhHJhPdQxbiAIguMBTQZrPD7108M6roWYDFQiIAAv6Aow/1bFwXgis+f2LUAynwoIaNcz8XNx3Dl7MEJUDGQpx9gtQ8YCueB+D26OECAAQDadt7e46D42QAAAABJRU5ErkJggg==) 2px 1px no-repeat;height:7px;width:8px}.dg li.save-row .button:hover{background-color:#bab19e;box-shadow:0 -1px 0 #b0a58f}.dg li.folder{border-bottom:0}.dg li.title{padding-left:16px;background:#000 url(data:image/gif;base64,R0lGODlhBQAFAJEAAP////Pz8////////yH5BAEAAAIALAAAAAAFAAUAAAIIlI+hKgFxoCgAOw==) 6px 10px no-repeat;cursor:pointer;border-bottom:1px solid hsla(0,0%,100%,.2)}.dg .closed li.title{background-image:url(data:image/gif;base64,R0lGODlhBQAFAJEAAP////Pz8////////yH5BAEAAAIALAAAAAAFAAUAAAIIlGIWqMCbWAEAOw==)}.dg .cr.boolean{border-left:3px solid #806787}.dg .cr.color{border-left:3px solid}.dg .cr.function{border-left:3px solid #e61d5f}.dg .cr.number{border-left:3px solid #2fa1d6}.dg .cr.number input[type=text]{color:#2fa1d6}.dg .cr.string{border-left:3px solid #1ed36f}.dg .cr.string input[type=text]{color:#1ed36f}.dg .cr.boolean:hover,.dg .cr.function:hover{background:#111}.dg .c input[type=text]{background:#303030;outline:none}.dg .c input[type=text]:hover{background:#3c3c3c}.dg .c input[type=text]:focus{background:#494949;color:#fff}.dg .c .slider{background:#303030;cursor:ew-resize}.dg .c .slider-fg{background:#2fa1d6;max-width:100%}.dg .c .slider:hover{background:#3c3c3c}.dg .c .slider:hover .slider-fg{background:#44abda}",""])},function(e,t){e.exports=function(){var e=[];return e.toString=function(){for(var e=[],t=0;t/dev/null 2>&1 &
-sleep 5
-open http://127.0.0.1:7860
-echo Finished opening ChuanhuChatGPT (http://127.0.0.1:7860/). If you kill ChuanhuChatbot, Use "pkill -f 'ChuanhuChatbot'" command in terminal.
\ No newline at end of file
diff --git a/spaces/bioriAsaeru/text-to-voice/13 things mentally strong people dont do pdf free download The best-selling book that will change your life.md b/spaces/bioriAsaeru/text-to-voice/13 things mentally strong people dont do pdf free download The best-selling book that will change your life.md
deleted file mode 100644
index 2adc5fcd4c677eddee223484168cb0a01de21468..0000000000000000000000000000000000000000
--- a/spaces/bioriAsaeru/text-to-voice/13 things mentally strong people dont do pdf free download The best-selling book that will change your life.md
+++ /dev/null
@@ -1,6 +0,0 @@
-13 things mentally strong people don't do pdf free download
DOWNLOAD ✸ https://urloso.com/2uyS93
-
- aaccfb2cb3
-
-
-
diff --git a/spaces/bioriAsaeru/text-to-voice/Aastha In The Prison Of Spring part 2 full movie online free - Rekha and Om Puris controversial role.md b/spaces/bioriAsaeru/text-to-voice/Aastha In The Prison Of Spring part 2 full movie online free - Rekha and Om Puris controversial role.md
deleted file mode 100644
index ce6854f323c2e92624a9f67ec3923de66f61d6c7..0000000000000000000000000000000000000000
--- a/spaces/bioriAsaeru/text-to-voice/Aastha In The Prison Of Spring part 2 full movie online free - Rekha and Om Puris controversial role.md
+++ /dev/null
@@ -1,6 +0,0 @@
-Aastha: In The Prison Of Spring part 2 full movie online free
DOWNLOAD ✒ https://urloso.com/2uyOAK
-
- aaccfb2cb3
-
-
-
diff --git a/spaces/bioriAsaeru/text-to-voice/Brickhouse Betty Site Rip Extra Quality.md b/spaces/bioriAsaeru/text-to-voice/Brickhouse Betty Site Rip Extra Quality.md
deleted file mode 100644
index 7d0c258a5dfa4444c214b673acdee49845f16a0c..0000000000000000000000000000000000000000
--- a/spaces/bioriAsaeru/text-to-voice/Brickhouse Betty Site Rip Extra Quality.md
+++ /dev/null
@@ -1,16 +0,0 @@
-
-170199 A.R.A. v. Commonwealth 03/01/2018 In a petition to expunge a felony arrest record, the trial court erred in concluding that the existence of this record may not cause the petitioner a manifest injustice. The facts underlying the arrest are irrelevant and the petitioner need not show actual prejudice to prevail on her expungement petition. She needs only to demonstrate that the continued existence of an arrest record may cause a manifest injustice. On this record, there is a reasonable possibility that a felony arrest record would hinder her career and her educational opportunities. It is concluded that the petitioner made the requisite showing of a manifest injustice. The judgment is reversed and the matter is remanded for entry of an order expunging the felony arrest record at issue.
-Brickhouse Betty Site Rip
Download ::: https://urloso.com/2uyPsb
-101006 Livingston v. Va. Dep't of Transportation 06/07/2012 (Revised 08/02/2012) In a suit for property damage under the Just Compensation Clause in Article I, Section 11 of the Constitution of Virginia, it is held that a single event of flooding can support an inverse condemnation claim, and that the plaintiffs' allegations that their homes and various items of personal property were damaged for a public use under Article I, Section 11 are sufficient to withstand demurrer. When VDOT constructs an improvement for the public benefit, it does not thereby become an insurer in perpetuity against flood damage to neighboring property, but a property owner may be entitled to compensation under Article I, Section 11 if VDOT's operation of that improvement causes damage to real or personal property. Thus, where VDOT relocated the channel of a waterway in order to permit highway construction, but failed to maintain the relocated channel via dredging or otherwise, and that failure is alleged to have impacted the magnitude of the damage plaintiffs suffered as the result of the single flooding event at issue, VDOT's choice not to maintain the relocated channel evinced its election to use the highway and nearby residential developments as makeshift storage sites for excess stormwater instead of allocating its resources to maintain the relocated channel. The contentions that plaintiffs lack standing to maintain an inverse condemnation suit and that they cannot recover under Article I, Section 11 for damage to personal property, are rejected. The circuit court's judgment is reversed and the case is remanded for further proceedings.
-100149 Scott v. Burwell's Bay Improvement Ass'n 04/21/2011 In a case involving riparian rights, the circuit court did not err in ruling that a party seeking to establish ownership of riparian rights by adverse possession, or, alternately, a prescriptive easement to use those rights, failed to prove these claims by clear and convincing evidence. The evidence to show that the use of the riparian rights was exclusive and continuous for the required period of time fell well below the clear and convincing standard required to prove adverse possession or prescriptive use of the riparian rights by the immediate prior occupants. Thus tacking was not available to establish the requisite time periods. The judgment of the circuit court is affirmed.
-100303 Condominium Services v. First Owners' Ass'n 04/21/2011 (Revised 05/25/2011) In a lawsuit between a condominium owners' association and a management services company, the circuit court did not err in sustaining the association's demurrers and striking an affirmative defense. The agreement between the parties, although it referenced the association's bylaws, did not require a three-fourths vote of the unit owners before the association could terminate the services of the management agent. The circuit court also did not err in denying a motion to dismiss the association's conversion claim, because the agreement had been terminated at the time the management company caused over $90,000 in fees to be deposited to its own bank account, and it was not error to grant summary judgment on the conversion claim. Expert witness designations, testimony regarding damages, punitive damages and remittitur are also discussed. The judgment is affirmed.
-
-091430 Commonwealth v. AMEC Civil 09/16/2010 In a construction contract dispute in which the plaintiff contractor and the defendant Virginia Department of Transportation both assign error, issues are discussed concerning timely notice of claims, whether sustained elevated lake water levels constitute a differing site condition under the contract, entitlement to home office overhead damages, calculation of actual costs as a basis for an award of damages, and entitlement to pre-judgment interest as an element of damages. The judgment of the Court of Appeals is affirmed in part and reversed in part, and the cases are remanded for the circuit court to recalculate damages.
-Bill was passionate about being active in the community he loved. In the past he served for eight years on the Middletown Town Council. He was the president of the Potter League for Animals, and was instrumental in its relocation to its present site. He served on the Boards of Newport Hospital, The Newport County YMCA, The Preservation Society of Newport County, The Rhode Island Foundation, and Newport Federal Savings Bank. He was actively involved in capital campaigns for The Maher Center and Newport Hospital. He was presently on the Board of Savings Institute Bank & Trust, was serving as legal counsel to The Newport County Chamber of Commerce, and was a member of the YMCA finance committee.
-Subject: Andrea
Date: Wed, 23 Jun 2004 16:40:27 -0400
From: "hannahrichard" hannahrichard@cox.net
To: Bryan@DenProductions.com
Dear Bryan,
One idea I had for the Great Bridge High School site was some sort of memorial for one of my friends,Andrea(rising sophomore)B. Deller, who passed away on June 19, 2004. I think it would be somethingthat many people would appreciate because so many of us were friends with her. In case you do notknow, the details are found below. Please consider this suggestion, because she meant so much tomany of us.
Yours sincerely,
Hannah Richard
-Along with Andrea, our class has also lost two other people taken too soon, Miss April CarolynTownes and Mr Nicholas Stephen Rosso. Both were dear to our class and will be greatly missed duringour senior year. I'm sure many of their friends and family would appreciate their being added tothis site, because they are surely not forgotten.
Thanks,
Kate Welsh
-Hi Bryan my name is Sarah Devincenzi Ferguson who was a drop out which i will advise no one to follow me in doing so. however Iwent to school with carole and knew her from the first grade. She always was a beautiful person inside and out. I still have a valentinecard that she gave me! I have cherished every memory of every one i have met . She was special and i hope she did well in her life.The card was signed "to my best friend ever!" well a lot of the past has changed but never the memories of all the nice people I met in school.I never remember bad things going on at great bridge high school in the 1960's. I went on to educate myself and I still am doing that.Stay in school kids even though I did not I am still married to the love of my life and it will be 52 years of ups and downs. I waslucky but not all are. So my advice is if you do not want to struggle through life get an education. Respect yourself and others. Thank you Bryan.
well wishes to all
Sarah D Ferguson
Hi Bryan. This is Sarah Ferguson again. My husband Jim Ferguson graduated from Great Bridge High in 1961. I recently replied to the request from CaroleSheltons family. Now I am told by Jim Ferguson that many of our classmates and neighbors have passed. I am so sad to hear that they had left us so earlyin their lives. Angela Sabato and I went to school together and were the quiet shy ones lol. Well I moved to sparrow road and met Jimmy who lived next door.We did not have to get married but back then it was a time when you had to move on and let your friends not be influenced by your actions. It was the bestof times when I knew all these nice people. Bryan do keep this site going. It helps us all to remember to reflect to pray and to realize that every secondon earth is precious and all of the young people on here seem to be very happy and doing well with their lives and I hope that life will continue to be precious to them.Thank you again Bryan and good luck to you also! Sincerely Sarah D Ferguson p.s. I did choose a very good man and life and I continued my education and Jim receivedhis masters degree from North Carolina State. Sometimes God has plans for us that we do not even know about.
-Hello Bryan,
I came across your website whle doing an internet search on my Dads high school. His name was Lawrence Wayne Proctor,class of 1965 and passed away on August 26, 2011. If you would could you please include him on the "In Memoriam" page, thank you.
I do not have any high school pictures of him such as yearbook pictures or maybe some classmates have pictures with him. Could youpost a note on your website requesting of those who know my Dad to send me yearbook pictures etc they might have. Also, anyone thatmay have stories of my Dad they would like to share I would most interested to hear. My email is mwpphx@cox.net
Thank you,
Mark Proctor
-Hi, I was looking up the name of one of my class mates Chris Ivey whom passed too soon. I notice that another studentthat we lost while in middle school that should of graduated with us ( CHRIS IVEY) and myself in 1993 was Vincent Mercerwas not on your page. I agree with whomever gave you the idea to start this page. These wonderful people were in our life'sand need to be remembered!!!!
Here are 2 pictures from my year book from 6th Grade.
Thanks
RIP VINCENT AND CHRIS you two are gone but NEVER NEVER forgotten!!!
I wrote you yesterday about adding Vincent Mercer whom I attended school with. I was looking on your website and didn't seeanother friend of mine that passed too soon. Warren T Trueblood Jr....He Graduated in 1989 from Great Bridge. His birthdayis May 24, 1970 and death date was Jan.14,1994- 23yrs old. He was like a brother to me, I was best friends growing upand still friends with his sister. Her daughter and my daughter/children have grown up together and it would be awesometo have him added to this board. He was a great, sweet, gentle person!!! I think of him often and all the times I sharedwith him and his sister. Well his whole family...Thank you for your time. God Bless.
Betty J Lewis-Kendrick CO 93 GBH
aaccfb2cb3
-
-
\ No newline at end of file
diff --git a/spaces/bioriAsaeru/text-to-voice/Comsol Multiphysics 4.3 Crack _BEST_ License File Torrent. Process Titl.md b/spaces/bioriAsaeru/text-to-voice/Comsol Multiphysics 4.3 Crack _BEST_ License File Torrent. Process Titl.md
deleted file mode 100644
index 7e213786920cdcb934ba674c6e8199b5124a0d28..0000000000000000000000000000000000000000
--- a/spaces/bioriAsaeru/text-to-voice/Comsol Multiphysics 4.3 Crack _BEST_ License File Torrent. Process Titl.md
+++ /dev/null
@@ -1,6 +0,0 @@
-Comsol Multiphysics 4.3 Crack License File Torrent. process titl
Download ✓✓✓ https://urloso.com/2uyReH
-
- 4d29de3e1b
-
-
-
diff --git a/spaces/bioriAsaeru/text-to-voice/Download Ccboot 2.1 Full Crack How to Install and Configure the Best Diskless Boot Solution.md b/spaces/bioriAsaeru/text-to-voice/Download Ccboot 2.1 Full Crack How to Install and Configure the Best Diskless Boot Solution.md
deleted file mode 100644
index 14f413d5e80458b149d21cd2a53caea542a7642f..0000000000000000000000000000000000000000
--- a/spaces/bioriAsaeru/text-to-voice/Download Ccboot 2.1 Full Crack How to Install and Configure the Best Diskless Boot Solution.md
+++ /dev/null
@@ -1,6 +0,0 @@
-Download Ccboot 2.1 Full Crack
DOWNLOAD 🗹 https://urloso.com/2uyOpg
-
- aaccfb2cb3
-
-
-
diff --git a/spaces/bioriAsaeru/text-to-voice/Economics Lipsey And Chrystal 12th Edition Free Download98.md b/spaces/bioriAsaeru/text-to-voice/Economics Lipsey And Chrystal 12th Edition Free Download98.md
deleted file mode 100644
index 914b414c3760fb266f80f0f68ce0e19d8bf6ec04..0000000000000000000000000000000000000000
--- a/spaces/bioriAsaeru/text-to-voice/Economics Lipsey And Chrystal 12th Edition Free Download98.md
+++ /dev/null
@@ -1,16 +0,0 @@
-
-How to Download Economics by Lipsey and Chrystal 12th Edition for Free
-Economics by Lipsey and Chrystal is a popular textbook that covers the essential principles and theory of microeconomics and macroeconomics. The 12th edition of this book was published in 2011 and provides a comprehensive and up-to-date review of the field. It also includes extensive practical applications and examples that help students understand the real-world relevance of the material.
-Economics Lipsey And Chrystal 12th Edition Free Download98
Download File --->>> https://urloso.com/2uyOqT
-If you are looking for a free download of Economics by Lipsey and Chrystal 12th edition, you may have a hard time finding a legitimate and legal source. Many websites that claim to offer free downloads of this book are either scams, viruses, or infringe on the authors' copyrights. Therefore, you should be careful and avoid clicking on any suspicious links or downloading any files from unknown sources.
-One way to access Economics by Lipsey and Chrystal 12th edition for free is to use your library's online resources. Many libraries have subscriptions to e-book platforms that allow you to borrow or read digital copies of textbooks online. You can check your library's website or catalog to see if they have Economics by Lipsey and Chrystal 12th edition available as an e-book. If they do, you can use your library card number and password to access it.
-Another way to access Economics by Lipsey and Chrystal 12th edition for free is to use a reputable academic website that offers open access to textbooks. For example, you can try OpenStax, which is a non-profit organization that provides free, high-quality textbooks for various subjects. You can browse their catalog and see if they have a book that covers the same topics as Economics by Lipsey and Chrystal 12th edition. You can then download or read the book online for free.
-A third way to access Economics by Lipsey and Chrystal 12th edition for free is to use a peer-to-peer sharing platform that allows you to exchange files with other users. For example, you can try Library Genesis, which is a website that hosts millions of books, articles, and other documents. You can search for Economics by Lipsey and Chrystal 12th edition on their website and see if they have a PDF or EPUB file that you can download. However, you should be aware that this method may be illegal in some countries or regions, as it may violate the authors' intellectual property rights. Therefore, you should use this method at your own risk and discretion.
-
-In conclusion, there are several ways to download Economics by Lipsey and Chrystal 12th edition for free, but not all of them are safe, legal, or ethical. You should always respect the authors' work and rights, and only use sources that are authorized or licensed to distribute their books. If you want to support the authors and publishers, you can also consider buying a copy of the book from a reputable online or offline bookstore.
-
-Economics by Lipsey and Chrystal 12th edition is a comprehensive textbook that covers both microeconomics and macroeconomics. Microeconomics is the branch of economics that studies the behavior and decisions of individual agents, such as consumers, firms, and households. Macroeconomics is the branch of economics that studies the behavior and performance of the aggregate economy, such as national income, inflation, unemployment, and growth.
-The book is divided into six parts. The first part introduces the basic concepts and tools of economics, such as scarcity, opportunity cost, demand and supply, elasticity, and market equilibrium. The second part covers the theory of consumer behavior, production and costs, market structures, and market failure. The third part covers the measurement and determination of national income, aggregate demand and supply, money and banking, and inflation and unemployment. The fourth part covers the theory of economic growth, fiscal policy, monetary policy, and international trade and finance. The fifth part covers the issues and challenges of economic development, poverty and inequality, environmental economics, and public choice. The sixth part covers the history of economic thought, from Adam Smith to John Maynard Keynes.
-The book is written in a clear and engaging style, with numerous examples and applications from various countries and regions. It also includes graphs, tables, diagrams, boxes, summaries, exercises, and review questions to help students understand and apply the material. The book is suitable for undergraduate students who are taking introductory or intermediate courses in economics. It is also a useful reference for anyone who wants to learn more about the principles and practice of economics.
d5da3c52bf
-
-
\ No newline at end of file
diff --git a/spaces/bioriAsaeru/text-to-voice/Fundamentos De Fisica Frank Blatt.md b/spaces/bioriAsaeru/text-to-voice/Fundamentos De Fisica Frank Blatt.md
deleted file mode 100644
index 10c0f9f7591631302dc81d4efaeade24f8c8fef3..0000000000000000000000000000000000000000
--- a/spaces/bioriAsaeru/text-to-voice/Fundamentos De Fisica Frank Blatt.md
+++ /dev/null
@@ -1,6 +0,0 @@
-Fundamentos De Fisica Frank Blatt
Download Zip ✶✶✶ https://urloso.com/2uyQbm
-
-rel regulator dan motor power windows honda fundamentos de fisica para ... 64 Blatt Bedrucktes · Memo Guide De Biologie Et De Physiologie Humaines Ue 2 1 ... Elle Sappelait Anne Frank Lhistoire De La Femme Qui Aida La Famille Frank A ... 1fdad05405
-
-
-
diff --git a/spaces/bla/tranny/App/Embedding/utils/Initialize.py b/spaces/bla/tranny/App/Embedding/utils/Initialize.py
deleted file mode 100644
index 5420886869e95906bef34e737c435308b6f04f1f..0000000000000000000000000000000000000000
--- a/spaces/bla/tranny/App/Embedding/utils/Initialize.py
+++ /dev/null
@@ -1,66 +0,0 @@
-from langchain.embeddings import HuggingFaceEmbeddings
-from langchain.docstore.document import Document
-from langchain.vectorstores import Pinecone
-import pinecone
-import os
-
-# get api key from app.pinecone.io
-PINECONE_API_KEY = os.environ.get("PINECONE_API_KEY")
-# find your environment next to the api key in pinecone console
-PINECONE_ENV = os.environ.get("PINECONE_ENVIRONMENT")
-
-
-index_name = "transcript-bits"
-model_name = "thenlper/gte-base"
-embeddings = HuggingFaceEmbeddings(model_name=model_name)
-
-
-pinecone.init(api_key=PINECONE_API_KEY, environment=PINECONE_ENV)
-vector_index = pinecone.Index(index_name=index_name)
-docsearch = Pinecone.from_existing_index(index_name, embeddings)
-
-
-async def delete_documents(task_id):
- docsearch.delete(
- filter={
- "task_id": {"$eq": "task_id"},
- }
- )
-
-
-
-def generateChunks(chunks, task_id, n=100):
- combined = [chunks[i : i + n] for i in range(0, len(chunks), n)]
- result = []
- for chunk in combined:
- data = {"text": ""}
- for item in chunk:
- if chunk.index(item) == 0:
- data["start"] = item["start"]
- if chunk.index(item) == len(chunk) - 1:
- data["end"] = item["end"]
- data["text"] += " " + item["text"]
-
- temp = Document(
- page_content=data["text"],
- metadata={"start": data["start"], "end": data["end"], "task_id": task_id},
- )
- result.append(temp)
- return result
-
-
-def search(query: str, task_id: str):
- filtering_conditions = {
- "task_id": {"$eq": "task_id"},
- }
- data =docsearch.similarity_search(query, k=4, filter=filtering_conditions)
- return [
- {"text": d.page_content, "start": d.metadata["start"], "end": d.metadata["end"]}
- for d in data
- ]
-
-
-
-def encode(temp: list[Document]):
- docsearch.add_documents(temp)
- # return embeddings.embed_documents(texts = [d.page_content for d in temp])
diff --git a/spaces/blmdsydm/faster-whisper-webui/app-shared.py b/spaces/blmdsydm/faster-whisper-webui/app-shared.py
deleted file mode 100644
index 63cac1a8adaf90784c5f5f178f86243ad2149ee4..0000000000000000000000000000000000000000
--- a/spaces/blmdsydm/faster-whisper-webui/app-shared.py
+++ /dev/null
@@ -1,5 +0,0 @@
-# Run the app with no audio file restrictions
-from app import create_ui
-from src.config import ApplicationConfig
-
-create_ui(ApplicationConfig.create_default(input_audio_max_duration=-1, share=True))
\ No newline at end of file
diff --git a/spaces/bunkalab/bunka-map/maps/violence_men_women.html b/spaces/bunkalab/bunka-map/maps/violence_men_women.html
deleted file mode 100644
index 54d0f0198417c48d84a4978318cb81727ccbfcc2..0000000000000000000000000000000000000000
--- a/spaces/bunkalab/bunka-map/maps/violence_men_women.html
+++ /dev/null
@@ -1,14 +0,0 @@
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/spaces/carlosalonso/Detection-video/carpeta_deteccion/tests/test_packaging.py b/spaces/carlosalonso/Detection-video/carpeta_deteccion/tests/test_packaging.py
deleted file mode 100644
index a5b1661e8f341fe66a6e02c59fe172bce445782b..0000000000000000000000000000000000000000
--- a/spaces/carlosalonso/Detection-video/carpeta_deteccion/tests/test_packaging.py
+++ /dev/null
@@ -1,24 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import unittest
-
-from detectron2.utils.collect_env import collect_env_info
-
-
-class TestProjects(unittest.TestCase):
- def test_import(self):
- from detectron2.projects import point_rend
-
- _ = point_rend.add_pointrend_config
-
- import detectron2.projects.deeplab as deeplab
-
- _ = deeplab.add_deeplab_config
-
- # import detectron2.projects.panoptic_deeplab as panoptic_deeplab
-
- # _ = panoptic_deeplab.add_panoptic_deeplab_config
-
-
-class TestCollectEnv(unittest.TestCase):
- def test(self):
- _ = collect_env_info()
diff --git a/spaces/carlosalonso/Detection-video/carpeta_deteccion/tools/deploy/README.md b/spaces/carlosalonso/Detection-video/carpeta_deteccion/tools/deploy/README.md
deleted file mode 100644
index e33cbeb54c003a5738da68c838fdaa4e0d218501..0000000000000000000000000000000000000000
--- a/spaces/carlosalonso/Detection-video/carpeta_deteccion/tools/deploy/README.md
+++ /dev/null
@@ -1,66 +0,0 @@
-See [deployment tutorial](https://detectron2.readthedocs.io/tutorials/deployment.html)
-for some high-level background about deployment.
-
-This directory contains the following examples:
-
-1. An example script `export_model.py`
- that exports a detectron2 model for deployment using different methods and formats.
-
-2. A C++ example that runs inference with Mask R-CNN model in TorchScript format.
-
-## Build
-Deployment depends on libtorch and OpenCV. Some require more dependencies:
-
-* Running TorchScript-format models produced by `--export-method=caffe2_tracing` requires libtorch
- to be built with caffe2 enabled.
-* Running TorchScript-format models produced by `--export-method=tracing/scripting` requires libtorchvision (C++ library of torchvision).
-
-All methods are supported in one C++ file that requires all the above dependencies.
-Adjust it and remove code you don't need.
-As a reference, we provide a [Dockerfile](../../docker/deploy.Dockerfile) that installs all the above dependencies and builds the C++ example.
-
-## Use
-
-We show a few example commands to export and execute a Mask R-CNN model in C++.
-
-* `export-method=tracing, format=torchscript`:
-```
-./export_model.py --config-file ../../configs/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml \
- --output ./output --export-method tracing --format torchscript \
- MODEL.WEIGHTS detectron2://COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x/137849600/model_final_f10217.pkl \
- MODEL.DEVICE cuda
-
-./build/torchscript_mask_rcnn output/model.ts input.jpg tracing
-```
-
-* `export-method=scripting, format=torchscript`:
-```
-./export_model.py --config-file ../../configs/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml \
- --output ./output --export-method scripting --format torchscript \
- MODEL.WEIGHTS detectron2://COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x/137849600/model_final_f10217.pkl \
-
-./build/torchscript_mask_rcnn output/model.ts input.jpg scripting
-```
-
-* `export-method=caffe2_tracing, format=torchscript`:
-
-```
-./export_model.py --config-file ../../configs/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml \
- --output ./output --export-method caffe2_tracing --format torchscript \
- MODEL.WEIGHTS detectron2://COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x/137849600/model_final_f10217.pkl \
-
-./build/torchscript_mask_rcnn output/model.ts input.jpg caffe2_tracing
-```
-
-
-## Notes:
-
-1. Tracing/Caffe2-tracing requires valid weights & sample inputs.
- Therefore the above commands require pre-trained models and [COCO dataset](https://detectron2.readthedocs.io/tutorials/builtin_datasets.html).
- You can modify the script to obtain sample inputs in other ways instead of from COCO.
-
-2. `--run-eval` is implemented only for tracing mode
- to evaluate the exported model using the dataset in the config.
- It's recommended to always verify the accuracy in case the conversion is not successful.
- Evaluation can be slow if model is exported to CPU or dataset is too large ("coco_2017_val_100" is a small subset of COCO useful for evaluation).
- `caffe2_tracing` accuracy may be slightly different (within 0.1 AP) from original model due to numerical precisions between different runtime.
diff --git a/spaces/chendl/compositional_test/transformers/src/transformers/models/albert/modeling_flax_albert.py b/spaces/chendl/compositional_test/transformers/src/transformers/models/albert/modeling_flax_albert.py
deleted file mode 100644
index 0ff1b9276a19d6a6ee101520f375a2af04a1defe..0000000000000000000000000000000000000000
--- a/spaces/chendl/compositional_test/transformers/src/transformers/models/albert/modeling_flax_albert.py
+++ /dev/null
@@ -1,1119 +0,0 @@
-# coding=utf-8
-# Copyright 2021 Google AI, Google Brain and the HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from typing import Callable, Optional, Tuple
-
-import flax
-import flax.linen as nn
-import jax
-import jax.numpy as jnp
-import numpy as np
-from flax.core.frozen_dict import FrozenDict, freeze, unfreeze
-from flax.linen.attention import dot_product_attention_weights
-from flax.traverse_util import flatten_dict, unflatten_dict
-from jax import lax
-
-from ...modeling_flax_outputs import (
- FlaxBaseModelOutput,
- FlaxBaseModelOutputWithPooling,
- FlaxMaskedLMOutput,
- FlaxMultipleChoiceModelOutput,
- FlaxQuestionAnsweringModelOutput,
- FlaxSequenceClassifierOutput,
- FlaxTokenClassifierOutput,
-)
-from ...modeling_flax_utils import (
- ACT2FN,
- FlaxPreTrainedModel,
- append_call_sample_docstring,
- append_replace_return_docstrings,
- overwrite_call_docstring,
-)
-from ...utils import ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward, logging
-from .configuration_albert import AlbertConfig
-
-
-logger = logging.get_logger(__name__)
-
-_CHECKPOINT_FOR_DOC = "albert-base-v2"
-_CONFIG_FOR_DOC = "AlbertConfig"
-
-
-@flax.struct.dataclass
-class FlaxAlbertForPreTrainingOutput(ModelOutput):
- """
- Output type of [`FlaxAlbertForPreTraining`].
-
- Args:
- prediction_logits (`jnp.ndarray` of shape `(batch_size, sequence_length, config.vocab_size)`):
- Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
- sop_logits (`jnp.ndarray` of shape `(batch_size, 2)`):
- Prediction scores of the next sequence prediction (classification) head (scores of True/False continuation
- before SoftMax).
- hidden_states (`tuple(jnp.ndarray)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
- Tuple of `jnp.ndarray` (one for the output of the embeddings + one for the output of each layer) of shape
- `(batch_size, sequence_length, hidden_size)`.
-
- Hidden-states of the model at the output of each layer plus the initial embedding outputs.
- attentions (`tuple(jnp.ndarray)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
- Tuple of `jnp.ndarray` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
- sequence_length)`.
-
- Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
- heads.
- """
-
- prediction_logits: jnp.ndarray = None
- sop_logits: jnp.ndarray = None
- hidden_states: Optional[Tuple[jnp.ndarray]] = None
- attentions: Optional[Tuple[jnp.ndarray]] = None
-
-
-ALBERT_START_DOCSTRING = r"""
-
- This model inherits from [`FlaxPreTrainedModel`]. Check the superclass documentation for the generic methods the
- library implements for all its model (such as downloading, saving and converting weights from PyTorch models)
-
- This model is also a Flax Linen [flax.linen.Module](https://flax.readthedocs.io/en/latest/flax.linen.html#module)
- subclass. Use it as a regular Flax linen Module and refer to the Flax documentation for all matter related to
- general usage and behavior.
-
- Finally, this model supports inherent JAX features such as:
-
- - [Just-In-Time (JIT) compilation](https://jax.readthedocs.io/en/latest/jax.html#just-in-time-compilation-jit)
- - [Automatic Differentiation](https://jax.readthedocs.io/en/latest/jax.html#automatic-differentiation)
- - [Vectorization](https://jax.readthedocs.io/en/latest/jax.html#vectorization-vmap)
- - [Parallelization](https://jax.readthedocs.io/en/latest/jax.html#parallelization-pmap)
-
- Parameters:
- config ([`AlbertConfig`]): Model configuration class with all the parameters of the model.
- Initializing with a config file does not load the weights associated with the model, only the
- configuration. Check out the [`~FlaxPreTrainedModel.from_pretrained`] method to load the model weights.
- dtype (`jax.numpy.dtype`, *optional*, defaults to `jax.numpy.float32`):
- The data type of the computation. Can be one of `jax.numpy.float32`, `jax.numpy.float16` (on GPUs) and
- `jax.numpy.bfloat16` (on TPUs).
-
- This can be used to enable mixed-precision training or half-precision inference on GPUs or TPUs. If
- specified all the computation will be performed with the given `dtype`.
-
- **Note that this only specifies the dtype of the computation and does not influence the dtype of model
- parameters.**
-
- If you wish to change the dtype of the model parameters, see [`~FlaxPreTrainedModel.to_fp16`] and
- [`~FlaxPreTrainedModel.to_bf16`].
-"""
-
-ALBERT_INPUTS_DOCSTRING = r"""
- Args:
- input_ids (`numpy.ndarray` of shape `({0})`):
- Indices of input sequence tokens in the vocabulary.
-
- Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
- [`PreTrainedTokenizer.__call__`] for details.
-
- [What are input IDs?](../glossary#input-ids)
- attention_mask (`numpy.ndarray` of shape `({0})`, *optional*):
- Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
-
- - 1 for tokens that are **not masked**,
- - 0 for tokens that are **masked**.
-
- [What are attention masks?](../glossary#attention-mask)
- token_type_ids (`numpy.ndarray` of shape `({0})`, *optional*):
- Segment token indices to indicate first and second portions of the inputs. Indices are selected in `[0,
- 1]`:
-
- - 0 corresponds to a *sentence A* token,
- - 1 corresponds to a *sentence B* token.
-
- [What are token type IDs?](../glossary#token-type-ids)
- position_ids (`numpy.ndarray` of shape `({0})`, *optional*):
- Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0,
- config.max_position_embeddings - 1]`.
- return_dict (`bool`, *optional*):
- Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
-
-"""
-
-
-class FlaxAlbertEmbeddings(nn.Module):
- """Construct the embeddings from word, position and token_type embeddings."""
-
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32 # the dtype of the computation
-
- def setup(self):
- self.word_embeddings = nn.Embed(
- self.config.vocab_size,
- self.config.embedding_size,
- embedding_init=jax.nn.initializers.normal(stddev=self.config.initializer_range),
- )
- self.position_embeddings = nn.Embed(
- self.config.max_position_embeddings,
- self.config.embedding_size,
- embedding_init=jax.nn.initializers.normal(stddev=self.config.initializer_range),
- )
- self.token_type_embeddings = nn.Embed(
- self.config.type_vocab_size,
- self.config.embedding_size,
- embedding_init=jax.nn.initializers.normal(stddev=self.config.initializer_range),
- )
- self.LayerNorm = nn.LayerNorm(epsilon=self.config.layer_norm_eps, dtype=self.dtype)
- self.dropout = nn.Dropout(rate=self.config.hidden_dropout_prob)
-
- # Copied from transformers.models.bert.modeling_flax_bert.FlaxBertEmbeddings.__call__
- def __call__(self, input_ids, token_type_ids, position_ids, deterministic: bool = True):
- # Embed
- inputs_embeds = self.word_embeddings(input_ids.astype("i4"))
- position_embeds = self.position_embeddings(position_ids.astype("i4"))
- token_type_embeddings = self.token_type_embeddings(token_type_ids.astype("i4"))
-
- # Sum all embeddings
- hidden_states = inputs_embeds + token_type_embeddings + position_embeds
-
- # Layer Norm
- hidden_states = self.LayerNorm(hidden_states)
- hidden_states = self.dropout(hidden_states, deterministic=deterministic)
- return hidden_states
-
-
-class FlaxAlbertSelfAttention(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32 # the dtype of the computation
-
- def setup(self):
- if self.config.hidden_size % self.config.num_attention_heads != 0:
- raise ValueError(
- "`config.hidden_size`: {self.config.hidden_size} has to be a multiple of `config.num_attention_heads` "
- " : {self.config.num_attention_heads}"
- )
-
- self.query = nn.Dense(
- self.config.hidden_size,
- dtype=self.dtype,
- kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
- )
- self.key = nn.Dense(
- self.config.hidden_size,
- dtype=self.dtype,
- kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
- )
- self.value = nn.Dense(
- self.config.hidden_size,
- dtype=self.dtype,
- kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
- )
- self.dense = nn.Dense(
- self.config.hidden_size,
- kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
- dtype=self.dtype,
- )
- self.LayerNorm = nn.LayerNorm(epsilon=self.config.layer_norm_eps, dtype=self.dtype)
- self.dropout = nn.Dropout(rate=self.config.hidden_dropout_prob)
-
- def __call__(self, hidden_states, attention_mask, deterministic=True, output_attentions: bool = False):
- head_dim = self.config.hidden_size // self.config.num_attention_heads
-
- query_states = self.query(hidden_states).reshape(
- hidden_states.shape[:2] + (self.config.num_attention_heads, head_dim)
- )
- value_states = self.value(hidden_states).reshape(
- hidden_states.shape[:2] + (self.config.num_attention_heads, head_dim)
- )
- key_states = self.key(hidden_states).reshape(
- hidden_states.shape[:2] + (self.config.num_attention_heads, head_dim)
- )
-
- # Convert the boolean attention mask to an attention bias.
- if attention_mask is not None:
- # attention mask in the form of attention bias
- attention_mask = jnp.expand_dims(attention_mask, axis=(-3, -2))
- attention_bias = lax.select(
- attention_mask > 0,
- jnp.full(attention_mask.shape, 0.0).astype(self.dtype),
- jnp.full(attention_mask.shape, jnp.finfo(self.dtype).min).astype(self.dtype),
- )
- else:
- attention_bias = None
-
- dropout_rng = None
- if not deterministic and self.config.attention_probs_dropout_prob > 0.0:
- dropout_rng = self.make_rng("dropout")
-
- attn_weights = dot_product_attention_weights(
- query_states,
- key_states,
- bias=attention_bias,
- dropout_rng=dropout_rng,
- dropout_rate=self.config.attention_probs_dropout_prob,
- broadcast_dropout=True,
- deterministic=deterministic,
- dtype=self.dtype,
- precision=None,
- )
-
- attn_output = jnp.einsum("...hqk,...khd->...qhd", attn_weights, value_states)
- attn_output = attn_output.reshape(attn_output.shape[:2] + (-1,))
-
- projected_attn_output = self.dense(attn_output)
- projected_attn_output = self.dropout(projected_attn_output, deterministic=deterministic)
- layernormed_attn_output = self.LayerNorm(projected_attn_output + hidden_states)
- outputs = (layernormed_attn_output, attn_weights) if output_attentions else (layernormed_attn_output,)
- return outputs
-
-
-class FlaxAlbertLayer(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32 # the dtype of the computation
-
- def setup(self):
- self.attention = FlaxAlbertSelfAttention(self.config, dtype=self.dtype)
- self.ffn = nn.Dense(
- self.config.intermediate_size,
- kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
- dtype=self.dtype,
- )
- self.activation = ACT2FN[self.config.hidden_act]
- self.ffn_output = nn.Dense(
- self.config.hidden_size,
- kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
- dtype=self.dtype,
- )
- self.full_layer_layer_norm = nn.LayerNorm(epsilon=self.config.layer_norm_eps, dtype=self.dtype)
- self.dropout = nn.Dropout(rate=self.config.hidden_dropout_prob)
-
- def __call__(
- self,
- hidden_states,
- attention_mask,
- deterministic: bool = True,
- output_attentions: bool = False,
- ):
- attention_outputs = self.attention(
- hidden_states, attention_mask, deterministic=deterministic, output_attentions=output_attentions
- )
- attention_output = attention_outputs[0]
- ffn_output = self.ffn(attention_output)
- ffn_output = self.activation(ffn_output)
- ffn_output = self.ffn_output(ffn_output)
- ffn_output = self.dropout(ffn_output, deterministic=deterministic)
- hidden_states = self.full_layer_layer_norm(ffn_output + attention_output)
-
- outputs = (hidden_states,)
-
- if output_attentions:
- outputs += (attention_outputs[1],)
- return outputs
-
-
-class FlaxAlbertLayerCollection(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32 # the dtype of the computation
-
- def setup(self):
- self.layers = [
- FlaxAlbertLayer(self.config, name=str(i), dtype=self.dtype) for i in range(self.config.inner_group_num)
- ]
-
- def __call__(
- self,
- hidden_states,
- attention_mask,
- deterministic: bool = True,
- output_attentions: bool = False,
- output_hidden_states: bool = False,
- ):
- layer_hidden_states = ()
- layer_attentions = ()
-
- for layer_index, albert_layer in enumerate(self.layers):
- layer_output = albert_layer(
- hidden_states,
- attention_mask,
- deterministic=deterministic,
- output_attentions=output_attentions,
- )
- hidden_states = layer_output[0]
-
- if output_attentions:
- layer_attentions = layer_attentions + (layer_output[1],)
-
- if output_hidden_states:
- layer_hidden_states = layer_hidden_states + (hidden_states,)
-
- outputs = (hidden_states,)
- if output_hidden_states:
- outputs = outputs + (layer_hidden_states,)
- if output_attentions:
- outputs = outputs + (layer_attentions,)
- return outputs # last-layer hidden state, (layer hidden states), (layer attentions)
-
-
-class FlaxAlbertLayerCollections(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32 # the dtype of the computation
- layer_index: Optional[str] = None
-
- def setup(self):
- self.albert_layers = FlaxAlbertLayerCollection(self.config, dtype=self.dtype)
-
- def __call__(
- self,
- hidden_states,
- attention_mask,
- deterministic: bool = True,
- output_attentions: bool = False,
- output_hidden_states: bool = False,
- ):
- outputs = self.albert_layers(
- hidden_states,
- attention_mask,
- deterministic=deterministic,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- )
- return outputs
-
-
-class FlaxAlbertLayerGroups(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32 # the dtype of the computation
-
- def setup(self):
- self.layers = [
- FlaxAlbertLayerCollections(self.config, name=str(i), layer_index=str(i), dtype=self.dtype)
- for i in range(self.config.num_hidden_groups)
- ]
-
- def __call__(
- self,
- hidden_states,
- attention_mask,
- deterministic: bool = True,
- output_attentions: bool = False,
- output_hidden_states: bool = False,
- return_dict: bool = True,
- ):
- all_attentions = () if output_attentions else None
- all_hidden_states = (hidden_states,) if output_hidden_states else None
-
- for i in range(self.config.num_hidden_layers):
- # Index of the hidden group
- group_idx = int(i / (self.config.num_hidden_layers / self.config.num_hidden_groups))
- layer_group_output = self.layers[group_idx](
- hidden_states,
- attention_mask,
- deterministic=deterministic,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- )
- hidden_states = layer_group_output[0]
-
- if output_attentions:
- all_attentions = all_attentions + layer_group_output[-1]
-
- if output_hidden_states:
- all_hidden_states = all_hidden_states + (hidden_states,)
-
- if not return_dict:
- return tuple(v for v in [hidden_states, all_hidden_states, all_attentions] if v is not None)
- return FlaxBaseModelOutput(
- last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_attentions
- )
-
-
-class FlaxAlbertEncoder(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32 # the dtype of the computation
-
- def setup(self):
- self.embedding_hidden_mapping_in = nn.Dense(
- self.config.hidden_size,
- kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
- dtype=self.dtype,
- )
- self.albert_layer_groups = FlaxAlbertLayerGroups(self.config, dtype=self.dtype)
-
- def __call__(
- self,
- hidden_states,
- attention_mask,
- deterministic: bool = True,
- output_attentions: bool = False,
- output_hidden_states: bool = False,
- return_dict: bool = True,
- ):
- hidden_states = self.embedding_hidden_mapping_in(hidden_states)
- return self.albert_layer_groups(
- hidden_states,
- attention_mask,
- deterministic=deterministic,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- )
-
-
-class FlaxAlbertOnlyMLMHead(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32
- bias_init: Callable[..., np.ndarray] = jax.nn.initializers.zeros
-
- def setup(self):
- self.dense = nn.Dense(self.config.embedding_size, dtype=self.dtype)
- self.activation = ACT2FN[self.config.hidden_act]
- self.LayerNorm = nn.LayerNorm(epsilon=self.config.layer_norm_eps, dtype=self.dtype)
- self.decoder = nn.Dense(self.config.vocab_size, dtype=self.dtype, use_bias=False)
- self.bias = self.param("bias", self.bias_init, (self.config.vocab_size,))
-
- def __call__(self, hidden_states, shared_embedding=None):
- hidden_states = self.dense(hidden_states)
- hidden_states = self.activation(hidden_states)
- hidden_states = self.LayerNorm(hidden_states)
-
- if shared_embedding is not None:
- hidden_states = self.decoder.apply({"params": {"kernel": shared_embedding.T}}, hidden_states)
- else:
- hidden_states = self.decoder(hidden_states)
-
- hidden_states += self.bias
- return hidden_states
-
-
-class FlaxAlbertSOPHead(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32
-
- def setup(self):
- self.dropout = nn.Dropout(self.config.classifier_dropout_prob)
- self.classifier = nn.Dense(2, dtype=self.dtype)
-
- def __call__(self, pooled_output, deterministic=True):
- pooled_output = self.dropout(pooled_output, deterministic=deterministic)
- logits = self.classifier(pooled_output)
- return logits
-
-
-class FlaxAlbertPreTrainedModel(FlaxPreTrainedModel):
- """
- An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
- models.
- """
-
- config_class = AlbertConfig
- base_model_prefix = "albert"
- module_class: nn.Module = None
-
- def __init__(
- self,
- config: AlbertConfig,
- input_shape: Tuple = (1, 1),
- seed: int = 0,
- dtype: jnp.dtype = jnp.float32,
- _do_init: bool = True,
- **kwargs,
- ):
- module = self.module_class(config=config, dtype=dtype, **kwargs)
- super().__init__(config, module, input_shape=input_shape, seed=seed, dtype=dtype, _do_init=_do_init)
-
- def init_weights(self, rng: jax.random.PRNGKey, input_shape: Tuple, params: FrozenDict = None) -> FrozenDict:
- # init input tensors
- input_ids = jnp.zeros(input_shape, dtype="i4")
- token_type_ids = jnp.zeros_like(input_ids)
- position_ids = jnp.broadcast_to(jnp.arange(jnp.atleast_2d(input_ids).shape[-1]), input_shape)
- attention_mask = jnp.ones_like(input_ids)
-
- params_rng, dropout_rng = jax.random.split(rng)
- rngs = {"params": params_rng, "dropout": dropout_rng}
-
- random_params = self.module.init(
- rngs, input_ids, attention_mask, token_type_ids, position_ids, return_dict=False
- )["params"]
-
- if params is not None:
- random_params = flatten_dict(unfreeze(random_params))
- params = flatten_dict(unfreeze(params))
- for missing_key in self._missing_keys:
- params[missing_key] = random_params[missing_key]
- self._missing_keys = set()
- return freeze(unflatten_dict(params))
- else:
- return random_params
-
- @add_start_docstrings_to_model_forward(ALBERT_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
- def __call__(
- self,
- input_ids,
- attention_mask=None,
- token_type_ids=None,
- position_ids=None,
- params: dict = None,
- dropout_rng: jax.random.PRNGKey = None,
- train: bool = False,
- output_attentions: Optional[bool] = None,
- output_hidden_states: Optional[bool] = None,
- return_dict: Optional[bool] = None,
- ):
- output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
- output_hidden_states = (
- output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
- )
- return_dict = return_dict if return_dict is not None else self.config.return_dict
-
- # init input tensors if not passed
- if token_type_ids is None:
- token_type_ids = jnp.zeros_like(input_ids)
-
- if position_ids is None:
- position_ids = jnp.broadcast_to(jnp.arange(jnp.atleast_2d(input_ids).shape[-1]), input_ids.shape)
-
- if attention_mask is None:
- attention_mask = jnp.ones_like(input_ids)
-
- # Handle any PRNG if needed
- rngs = {}
- if dropout_rng is not None:
- rngs["dropout"] = dropout_rng
-
- return self.module.apply(
- {"params": params or self.params},
- jnp.array(input_ids, dtype="i4"),
- jnp.array(attention_mask, dtype="i4"),
- jnp.array(token_type_ids, dtype="i4"),
- jnp.array(position_ids, dtype="i4"),
- not train,
- output_attentions,
- output_hidden_states,
- return_dict,
- rngs=rngs,
- )
-
-
-class FlaxAlbertModule(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32 # the dtype of the computation
- add_pooling_layer: bool = True
-
- def setup(self):
- self.embeddings = FlaxAlbertEmbeddings(self.config, dtype=self.dtype)
- self.encoder = FlaxAlbertEncoder(self.config, dtype=self.dtype)
- if self.add_pooling_layer:
- self.pooler = nn.Dense(
- self.config.hidden_size,
- kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
- dtype=self.dtype,
- name="pooler",
- )
- self.pooler_activation = nn.tanh
- else:
- self.pooler = None
- self.pooler_activation = None
-
- def __call__(
- self,
- input_ids,
- attention_mask,
- token_type_ids: Optional[np.ndarray] = None,
- position_ids: Optional[np.ndarray] = None,
- deterministic: bool = True,
- output_attentions: bool = False,
- output_hidden_states: bool = False,
- return_dict: bool = True,
- ):
- # make sure `token_type_ids` is correctly initialized when not passed
- if token_type_ids is None:
- token_type_ids = jnp.zeros_like(input_ids)
-
- # make sure `position_ids` is correctly initialized when not passed
- if position_ids is None:
- position_ids = jnp.broadcast_to(jnp.arange(jnp.atleast_2d(input_ids).shape[-1]), input_ids.shape)
-
- hidden_states = self.embeddings(input_ids, token_type_ids, position_ids, deterministic=deterministic)
-
- outputs = self.encoder(
- hidden_states,
- attention_mask,
- deterministic=deterministic,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
- hidden_states = outputs[0]
- if self.add_pooling_layer:
- pooled = self.pooler(hidden_states[:, 0])
- pooled = self.pooler_activation(pooled)
- else:
- pooled = None
-
- if not return_dict:
- # if pooled is None, don't return it
- if pooled is None:
- return (hidden_states,) + outputs[1:]
- return (hidden_states, pooled) + outputs[1:]
-
- return FlaxBaseModelOutputWithPooling(
- last_hidden_state=hidden_states,
- pooler_output=pooled,
- hidden_states=outputs.hidden_states,
- attentions=outputs.attentions,
- )
-
-
-@add_start_docstrings(
- "The bare Albert Model transformer outputting raw hidden-states without any specific head on top.",
- ALBERT_START_DOCSTRING,
-)
-class FlaxAlbertModel(FlaxAlbertPreTrainedModel):
- module_class = FlaxAlbertModule
-
-
-append_call_sample_docstring(FlaxAlbertModel, _CHECKPOINT_FOR_DOC, FlaxBaseModelOutputWithPooling, _CONFIG_FOR_DOC)
-
-
-class FlaxAlbertForPreTrainingModule(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32
-
- def setup(self):
- self.albert = FlaxAlbertModule(config=self.config, dtype=self.dtype)
- self.predictions = FlaxAlbertOnlyMLMHead(config=self.config, dtype=self.dtype)
- self.sop_classifier = FlaxAlbertSOPHead(config=self.config, dtype=self.dtype)
-
- def __call__(
- self,
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic: bool = True,
- output_attentions: bool = False,
- output_hidden_states: bool = False,
- return_dict: bool = True,
- ):
- # Model
- outputs = self.albert(
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic=deterministic,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
-
- if self.config.tie_word_embeddings:
- shared_embedding = self.albert.variables["params"]["embeddings"]["word_embeddings"]["embedding"]
- else:
- shared_embedding = None
-
- hidden_states = outputs[0]
- pooled_output = outputs[1]
-
- prediction_scores = self.predictions(hidden_states, shared_embedding=shared_embedding)
- sop_scores = self.sop_classifier(pooled_output, deterministic=deterministic)
-
- if not return_dict:
- return (prediction_scores, sop_scores) + outputs[2:]
-
- return FlaxAlbertForPreTrainingOutput(
- prediction_logits=prediction_scores,
- sop_logits=sop_scores,
- hidden_states=outputs.hidden_states,
- attentions=outputs.attentions,
- )
-
-
-@add_start_docstrings(
- """
- Albert Model with two heads on top as done during the pretraining: a `masked language modeling` head and a
- `sentence order prediction (classification)` head.
- """,
- ALBERT_START_DOCSTRING,
-)
-class FlaxAlbertForPreTraining(FlaxAlbertPreTrainedModel):
- module_class = FlaxAlbertForPreTrainingModule
-
-
-FLAX_ALBERT_FOR_PRETRAINING_DOCSTRING = """
- Returns:
-
- Example:
-
- ```python
- >>> from transformers import AutoTokenizer, FlaxAlbertForPreTraining
-
- >>> tokenizer = AutoTokenizer.from_pretrained("albert-base-v2")
- >>> model = FlaxAlbertForPreTraining.from_pretrained("albert-base-v2")
-
- >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="np")
- >>> outputs = model(**inputs)
-
- >>> prediction_logits = outputs.prediction_logits
- >>> seq_relationship_logits = outputs.sop_logits
- ```
-"""
-
-overwrite_call_docstring(
- FlaxAlbertForPreTraining,
- ALBERT_INPUTS_DOCSTRING.format("batch_size, sequence_length") + FLAX_ALBERT_FOR_PRETRAINING_DOCSTRING,
-)
-append_replace_return_docstrings(
- FlaxAlbertForPreTraining, output_type=FlaxAlbertForPreTrainingOutput, config_class=_CONFIG_FOR_DOC
-)
-
-
-class FlaxAlbertForMaskedLMModule(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32
-
- def setup(self):
- self.albert = FlaxAlbertModule(config=self.config, add_pooling_layer=False, dtype=self.dtype)
- self.predictions = FlaxAlbertOnlyMLMHead(config=self.config, dtype=self.dtype)
-
- def __call__(
- self,
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic: bool = True,
- output_attentions: bool = False,
- output_hidden_states: bool = False,
- return_dict: bool = True,
- ):
- # Model
- outputs = self.albert(
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic=deterministic,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
-
- hidden_states = outputs[0]
- if self.config.tie_word_embeddings:
- shared_embedding = self.albert.variables["params"]["embeddings"]["word_embeddings"]["embedding"]
- else:
- shared_embedding = None
-
- # Compute the prediction scores
- logits = self.predictions(hidden_states, shared_embedding=shared_embedding)
-
- if not return_dict:
- return (logits,) + outputs[1:]
-
- return FlaxMaskedLMOutput(
- logits=logits,
- hidden_states=outputs.hidden_states,
- attentions=outputs.attentions,
- )
-
-
-@add_start_docstrings("""Albert Model with a `language modeling` head on top.""", ALBERT_START_DOCSTRING)
-class FlaxAlbertForMaskedLM(FlaxAlbertPreTrainedModel):
- module_class = FlaxAlbertForMaskedLMModule
-
-
-append_call_sample_docstring(FlaxAlbertForMaskedLM, _CHECKPOINT_FOR_DOC, FlaxMaskedLMOutput, _CONFIG_FOR_DOC)
-
-
-class FlaxAlbertForSequenceClassificationModule(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32
-
- def setup(self):
- self.albert = FlaxAlbertModule(config=self.config, dtype=self.dtype)
- classifier_dropout = (
- self.config.classifier_dropout_prob
- if self.config.classifier_dropout_prob is not None
- else self.config.hidden_dropout_prob
- )
- self.dropout = nn.Dropout(rate=classifier_dropout)
- self.classifier = nn.Dense(
- self.config.num_labels,
- dtype=self.dtype,
- )
-
- def __call__(
- self,
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic: bool = True,
- output_attentions: bool = False,
- output_hidden_states: bool = False,
- return_dict: bool = True,
- ):
- # Model
- outputs = self.albert(
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic=deterministic,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
-
- pooled_output = outputs[1]
- pooled_output = self.dropout(pooled_output, deterministic=deterministic)
- logits = self.classifier(pooled_output)
-
- if not return_dict:
- return (logits,) + outputs[2:]
-
- return FlaxSequenceClassifierOutput(
- logits=logits,
- hidden_states=outputs.hidden_states,
- attentions=outputs.attentions,
- )
-
-
-@add_start_docstrings(
- """
- Albert Model transformer with a sequence classification/regression head on top (a linear layer on top of the pooled
- output) e.g. for GLUE tasks.
- """,
- ALBERT_START_DOCSTRING,
-)
-class FlaxAlbertForSequenceClassification(FlaxAlbertPreTrainedModel):
- module_class = FlaxAlbertForSequenceClassificationModule
-
-
-append_call_sample_docstring(
- FlaxAlbertForSequenceClassification,
- _CHECKPOINT_FOR_DOC,
- FlaxSequenceClassifierOutput,
- _CONFIG_FOR_DOC,
-)
-
-
-class FlaxAlbertForMultipleChoiceModule(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32
-
- def setup(self):
- self.albert = FlaxAlbertModule(config=self.config, dtype=self.dtype)
- self.dropout = nn.Dropout(rate=self.config.hidden_dropout_prob)
- self.classifier = nn.Dense(1, dtype=self.dtype)
-
- def __call__(
- self,
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic: bool = True,
- output_attentions: bool = False,
- output_hidden_states: bool = False,
- return_dict: bool = True,
- ):
- num_choices = input_ids.shape[1]
- input_ids = input_ids.reshape(-1, input_ids.shape[-1]) if input_ids is not None else None
- attention_mask = attention_mask.reshape(-1, attention_mask.shape[-1]) if attention_mask is not None else None
- token_type_ids = token_type_ids.reshape(-1, token_type_ids.shape[-1]) if token_type_ids is not None else None
- position_ids = position_ids.reshape(-1, position_ids.shape[-1]) if position_ids is not None else None
-
- # Model
- outputs = self.albert(
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic=deterministic,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
-
- pooled_output = outputs[1]
- pooled_output = self.dropout(pooled_output, deterministic=deterministic)
- logits = self.classifier(pooled_output)
-
- reshaped_logits = logits.reshape(-1, num_choices)
-
- if not return_dict:
- return (reshaped_logits,) + outputs[2:]
-
- return FlaxMultipleChoiceModelOutput(
- logits=reshaped_logits,
- hidden_states=outputs.hidden_states,
- attentions=outputs.attentions,
- )
-
-
-@add_start_docstrings(
- """
- Albert Model with a multiple choice classification head on top (a linear layer on top of the pooled output and a
- softmax) e.g. for RocStories/SWAG tasks.
- """,
- ALBERT_START_DOCSTRING,
-)
-class FlaxAlbertForMultipleChoice(FlaxAlbertPreTrainedModel):
- module_class = FlaxAlbertForMultipleChoiceModule
-
-
-overwrite_call_docstring(
- FlaxAlbertForMultipleChoice, ALBERT_INPUTS_DOCSTRING.format("batch_size, num_choices, sequence_length")
-)
-append_call_sample_docstring(
- FlaxAlbertForMultipleChoice,
- _CHECKPOINT_FOR_DOC,
- FlaxMultipleChoiceModelOutput,
- _CONFIG_FOR_DOC,
-)
-
-
-class FlaxAlbertForTokenClassificationModule(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32
-
- def setup(self):
- self.albert = FlaxAlbertModule(config=self.config, dtype=self.dtype, add_pooling_layer=False)
- classifier_dropout = (
- self.config.classifier_dropout_prob
- if self.config.classifier_dropout_prob is not None
- else self.config.hidden_dropout_prob
- )
- self.dropout = nn.Dropout(rate=classifier_dropout)
- self.classifier = nn.Dense(self.config.num_labels, dtype=self.dtype)
-
- def __call__(
- self,
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic: bool = True,
- output_attentions: bool = False,
- output_hidden_states: bool = False,
- return_dict: bool = True,
- ):
- # Model
- outputs = self.albert(
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic=deterministic,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
-
- hidden_states = outputs[0]
- hidden_states = self.dropout(hidden_states, deterministic=deterministic)
- logits = self.classifier(hidden_states)
-
- if not return_dict:
- return (logits,) + outputs[1:]
-
- return FlaxTokenClassifierOutput(
- logits=logits,
- hidden_states=outputs.hidden_states,
- attentions=outputs.attentions,
- )
-
-
-@add_start_docstrings(
- """
- Albert Model with a token classification head on top (a linear layer on top of the hidden-states output) e.g. for
- Named-Entity-Recognition (NER) tasks.
- """,
- ALBERT_START_DOCSTRING,
-)
-class FlaxAlbertForTokenClassification(FlaxAlbertPreTrainedModel):
- module_class = FlaxAlbertForTokenClassificationModule
-
-
-append_call_sample_docstring(
- FlaxAlbertForTokenClassification,
- _CHECKPOINT_FOR_DOC,
- FlaxTokenClassifierOutput,
- _CONFIG_FOR_DOC,
-)
-
-
-class FlaxAlbertForQuestionAnsweringModule(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32
-
- def setup(self):
- self.albert = FlaxAlbertModule(config=self.config, dtype=self.dtype, add_pooling_layer=False)
- self.qa_outputs = nn.Dense(self.config.num_labels, dtype=self.dtype)
-
- def __call__(
- self,
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic: bool = True,
- output_attentions: bool = False,
- output_hidden_states: bool = False,
- return_dict: bool = True,
- ):
- # Model
- outputs = self.albert(
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic=deterministic,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
-
- hidden_states = outputs[0]
-
- logits = self.qa_outputs(hidden_states)
- start_logits, end_logits = logits.split(self.config.num_labels, axis=-1)
- start_logits = start_logits.squeeze(-1)
- end_logits = end_logits.squeeze(-1)
-
- if not return_dict:
- return (start_logits, end_logits) + outputs[1:]
-
- return FlaxQuestionAnsweringModelOutput(
- start_logits=start_logits,
- end_logits=end_logits,
- hidden_states=outputs.hidden_states,
- attentions=outputs.attentions,
- )
-
-
-@add_start_docstrings(
- """
- Albert Model with a span classification head on top for extractive question-answering tasks like SQuAD (a linear
- layers on top of the hidden-states output to compute `span start logits` and `span end logits`).
- """,
- ALBERT_START_DOCSTRING,
-)
-class FlaxAlbertForQuestionAnswering(FlaxAlbertPreTrainedModel):
- module_class = FlaxAlbertForQuestionAnsweringModule
-
-
-append_call_sample_docstring(
- FlaxAlbertForQuestionAnswering,
- _CHECKPOINT_FOR_DOC,
- FlaxQuestionAnsweringModelOutput,
- _CONFIG_FOR_DOC,
-)
diff --git a/spaces/chenyangqi/FateZero/FateZero/video_diffusion/pipelines/DDIMSpatioTemporalStableDiffusionPipeline.py b/spaces/chenyangqi/FateZero/FateZero/video_diffusion/pipelines/DDIMSpatioTemporalStableDiffusionPipeline.py
deleted file mode 100644
index 5228dfa27bdf54081b9a075f3d4d7ea7a437d42f..0000000000000000000000000000000000000000
--- a/spaces/chenyangqi/FateZero/FateZero/video_diffusion/pipelines/DDIMSpatioTemporalStableDiffusionPipeline.py
+++ /dev/null
@@ -1,300 +0,0 @@
-# code mostly taken from https://github.com/huggingface/diffusers
-import inspect
-from typing import Callable, List, Optional, Union
-import PIL
-import torch
-import numpy as np
-from einops import rearrange
-from tqdm import trange, tqdm
-
-from diffusers.utils import deprecate, logging
-from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
-
-from ..models.unet_3d_condition import UNetPseudo3DConditionModel
-from .stable_diffusion import SpatioTemporalStableDiffusionPipeline
-
-logger = logging.get_logger(__name__) # pylint: disable=invalid-name
-
-
-class DDIMSpatioTemporalStableDiffusionPipeline(SpatioTemporalStableDiffusionPipeline):
- r"""
- Pipeline for text-to-video generation using Spatio-Temporal Stable Diffusion.
- """
-
- def check_inputs(self, prompt, height, width, callback_steps, strength=None):
- if not isinstance(prompt, str) and not isinstance(prompt, list):
- raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
- if strength is not None:
- if strength <= 0 or strength > 1:
- raise ValueError(f"The value of strength should in (0.0, 1.0] but is {strength}")
-
- if height % 8 != 0 or width % 8 != 0:
- raise ValueError(
- f"`height` and `width` have to be divisible by 8 but are {height} and {width}."
- )
-
- if (callback_steps is None) or (
- callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0)
- ):
- raise ValueError(
- f"`callback_steps` has to be a positive integer but is {callback_steps} of type"
- f" {type(callback_steps)}."
- )
-
-
-
- def prepare_latents_ddim_inverted(self, image, batch_size, num_images_per_prompt,
- # dtype, device,
- text_embeddings,
- generator=None):
-
- # Not sure if image need to change device and type
- # image = image.to(device=device, dtype=dtype)
-
- batch_size = batch_size * num_images_per_prompt
- if isinstance(generator, list) and len(generator) != batch_size:
- raise ValueError(
- f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
- f" size of {batch_size}. Make sure the batch size matches the length of the generators."
- )
-
- if isinstance(generator, list):
- init_latents = [
- self.vae.encode(image[i : i + 1]).latent_dist.sample(generator[i]) for i in range(batch_size)
- ]
- init_latents = torch.cat(init_latents, dim=0)
- else:
- init_latents = self.vae.encode(image).latent_dist.sample(generator)
- init_latents = 0.18215 * init_latents
-
- if batch_size > init_latents.shape[0] and batch_size % init_latents.shape[0] == 0:
- # expand init_latents for batch_size
- deprecation_message = (
- f"You have passed {batch_size} text prompts (`prompt`), but only {init_latents.shape[0]} initial"
- " images (`image`). Initial images are now duplicating to match the number of text prompts. Note"
- " that this behavior is deprecated and will be removed in a version 1.0.0. Please make sure to update"
- " your script to pass as many initial images as text prompts to suppress this warning."
- )
- deprecate("len(prompt) != len(image)", "1.0.0", deprecation_message, standard_warn=False)
- additional_image_per_prompt = batch_size // init_latents.shape[0]
- init_latents = torch.cat([init_latents] * additional_image_per_prompt, dim=0)
- elif batch_size > init_latents.shape[0] and batch_size % init_latents.shape[0] != 0:
- raise ValueError(
- f"Cannot duplicate `image` of batch size {init_latents.shape[0]} to {batch_size} text prompts."
- )
- else:
- init_latents = torch.cat([init_latents], dim=0)
-
- # get latents
- init_latents_bcfhw = rearrange(init_latents, "(b f) c h w -> b c f h w", b=batch_size)
- ddim_latents_all_step = self.ddim_clean2noisy_loop(init_latents_bcfhw, text_embeddings)
- return ddim_latents_all_step
-
- @torch.no_grad()
- def ddim_clean2noisy_loop(self, latent, text_embeddings):
- weight_dtype = latent.dtype
- uncond_embeddings, cond_embeddings = text_embeddings.chunk(2)
- all_latent = [latent]
- latent = latent.clone().detach()
- print(' Invert clean image to noise latents by DDIM and Unet')
- for i in trange(len(self.scheduler.timesteps)):
- t = self.scheduler.timesteps[len(self.scheduler.timesteps) - i - 1]
- # noise_pred = self.get_noise_pred_single(latent, t, cond_embeddings)
- noise_pred = self.unet(latent, t, encoder_hidden_states=cond_embeddings)["sample"] # [1, 4, 8, 64, 64] -> [1, 4, 8, 64, 64])
- latent = self.next_clean2noise_step(noise_pred, t, latent)
- all_latent.append(latent.to(dtype=weight_dtype))
-
- return all_latent
-
- def next_clean2noise_step(self, model_output: Union[torch.FloatTensor, np.ndarray], timestep: int, sample: Union[torch.FloatTensor, np.ndarray]):
- """
- Assume the eta in DDIM=0
- """
- timestep, next_timestep = min(timestep - self.scheduler.config.num_train_timesteps // self.scheduler.num_inference_steps, 999), timestep
- alpha_prod_t = self.scheduler.alphas_cumprod[timestep] if timestep >= 0 else self.scheduler.final_alpha_cumprod
- alpha_prod_t_next = self.scheduler.alphas_cumprod[next_timestep]
- beta_prod_t = 1 - alpha_prod_t
- next_original_sample = (sample - beta_prod_t ** 0.5 * model_output) / alpha_prod_t ** 0.5
- next_sample_direction = (1 - alpha_prod_t_next) ** 0.5 * model_output
- next_sample = alpha_prod_t_next ** 0.5 * next_original_sample + next_sample_direction
- return next_sample
-
- def get_timesteps(self, num_inference_steps, strength, device):
- # get the original timestep using init_timestep
- init_timestep = min(int(num_inference_steps * strength), num_inference_steps)
-
- t_start = max(num_inference_steps - init_timestep, 0)
- timesteps = self.scheduler.timesteps[t_start:]
-
- return timesteps, num_inference_steps - t_start
-
- @torch.no_grad()
- def __call__(
- self,
- prompt: Union[str, List[str]],
- image: Union[torch.FloatTensor, PIL.Image.Image] = None,
- height: Optional[int] = None,
- width: Optional[int] = None,
- strength: float = None,
- num_inference_steps: int = 50,
- clip_length: int = 8,
- guidance_scale: float = 7.5,
- negative_prompt: Optional[Union[str, List[str]]] = None,
- num_images_per_prompt: Optional[int] = 1,
- eta: float = 0.0,
- generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
- latents: Optional[torch.FloatTensor] = None,
- output_type: Optional[str] = "pil",
- return_dict: bool = True,
- callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
- callback_steps: Optional[int] = 1,
- **args
- ):
- r"""
- Function invoked when calling the pipeline for generation.
-
- Args:
- prompt (`str` or `List[str]`):
- The prompt or prompts to guide the image generation.
- image (`torch.FloatTensor` or `PIL.Image.Image`):
- `Image`, or tensor representing an image batch, that will be used as the starting point for the
- process. Only used in DDIM or strength<1.0
- height (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor):
- The height in pixels of the generated image.
- width (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor):
- The width in pixels of the generated image.
- strength (`float`, *optional*, defaults to 1.0):
- Conceptually, indicates how much to transform the reference `image`. Must be between 0 and 1. `image`
- will be used as a starting point, adding more noise to it the larger the `strength`. The number of
- denoising steps depends on the amount of noise initially added. When `strength` is 1, added noise will
- be maximum and the denoising process will run for the full number of iterations specified in
- `num_inference_steps`. A value of 1, therefore, essentially ignores `image`.
- num_inference_steps (`int`, *optional*, defaults to 50):
- The number of denoising steps. More denoising steps usually lead to a higher quality image at the
- expense of slower inference.
- guidance_scale (`float`, *optional*, defaults to 7.5):
- Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598).
- `guidance_scale` is defined as `w` of equation 2. of [Imagen
- Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale >
- 1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`,
- usually at the expense of lower image quality.
- negative_prompt (`str` or `List[str]`, *optional*):
- The prompt or prompts not to guide the image generation. Ignored when not using guidance (i.e., ignored
- if `guidance_scale` is less than `1`).
- num_images_per_prompt (`int`, *optional*, defaults to 1):
- The number of images to generate per prompt.
- eta (`float`, *optional*, defaults to 0.0):
- Corresponds to parameter eta (η) in the DDIM paper: https://arxiv.org/abs/2010.02502. Only applies to
- [`schedulers.DDIMScheduler`], will be ignored for others.
- generator (`torch.Generator`, *optional*):
- One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html)
- to make generation deterministic.
- latents (`torch.FloatTensor`, *optional*):
- Pre-generated noisy latents, sampled from a Gaussian distribution, to be used as inputs for image
- generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
- tensor will ge generated by sampling using the supplied random `generator`.
- output_type (`str`, *optional*, defaults to `"pil"`):
- The output format of the generate image. Choose between
- [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`.
- return_dict (`bool`, *optional*, defaults to `True`):
- Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a
- plain tuple.
- callback (`Callable`, *optional*):
- A function that will be called every `callback_steps` steps during inference. The function will be
- called with the following arguments: `callback(step: int, timestep: int, latents: torch.FloatTensor)`.
- callback_steps (`int`, *optional*, defaults to 1):
- The frequency at which the `callback` function will be called. If not specified, the callback will be
- called at every step.
-
- Returns:
- [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] or `tuple`:
- [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] if `return_dict` is True, otherwise a `tuple.
- When returning a tuple, the first element is a list with the generated images, and the second element is a
- list of `bool`s denoting whether the corresponding generated image likely represents "not-safe-for-work"
- (nsfw) content, according to the `safety_checker`.
- """
- # 0. Default height and width to unet
- height = height or self.unet.config.sample_size * self.vae_scale_factor
- width = width or self.unet.config.sample_size * self.vae_scale_factor
-
- # 1. Check inputs. Raise error if not correct
- self.check_inputs(prompt, height, width, callback_steps, strength)
-
- # 2. Define call parameters
- batch_size = 1 if isinstance(prompt, str) else len(prompt)
- device = self._execution_device
- # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
- # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
- # corresponds to doing no classifier free guidance.
- do_classifier_free_guidance = guidance_scale > 1.0
-
- # 3. Encode input prompt
- text_embeddings = self._encode_prompt(
- prompt, device, num_images_per_prompt, do_classifier_free_guidance, negative_prompt
- )
-
- # 4. Prepare timesteps
- self.scheduler.set_timesteps(num_inference_steps, device=device)
- # if strength <1.0:
- # timesteps, num_inference_steps = self.get_timesteps(num_inference_steps, strength, device)
- timesteps = self.scheduler.timesteps
- latent_timestep = timesteps[:1].repeat(batch_size * num_images_per_prompt)
- if latents is None:
- ddim_latents_all_step = self.prepare_latents_ddim_inverted(
- image, batch_size, num_images_per_prompt,
- # text_embeddings.dtype, device,
- text_embeddings,
- generator,
- )
- latents = ddim_latents_all_step[-1]
-
- latents_dtype = latents.dtype
-
- # 6. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
- extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)
-
- # 7. Denoising loop
- num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order
- with self.progress_bar(total=num_inference_steps) as progress_bar:
- for i, t in enumerate(tqdm(timesteps)):
- # expand the latents if we are doing classifier free guidance
- latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents
- latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
-
- # predict the noise residual
- noise_pred = self.unet(
- latent_model_input, t, encoder_hidden_states=text_embeddings
- ).sample.to(dtype=latents_dtype)
-
- # perform guidance
- if do_classifier_free_guidance:
- noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
- noise_pred = noise_pred_uncond + guidance_scale * (
- noise_pred_text - noise_pred_uncond
- )
-
- # compute the previous noisy sample x_t -> x_t-1
- latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs).prev_sample
-
- # call the callback, if provided
- if i == len(timesteps) - 1 or (
- (i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0
- ):
- progress_bar.update()
- if callback is not None and i % callback_steps == 0:
- callback(i, t, latents)
-
- # 8. Post-processing
- image = self.decode_latents(latents)
-
- # 9. Run safety checker
- has_nsfw_concept = None
-
- # 10. Convert to PIL
- if output_type == "pil":
- image = self.numpy_to_pil(image)
-
- if not return_dict:
- return (image, has_nsfw_concept)
- torch.cuda.empty_cache()
- return StableDiffusionPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept)
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/clickhouse_connect/driver/context.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/clickhouse_connect/driver/context.py
deleted file mode 100644
index 7984fbeebbe84f3b1d0b99ecb4f160a6affc423a..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/clickhouse_connect/driver/context.py
+++ /dev/null
@@ -1,72 +0,0 @@
-import logging
-import re
-from datetime import datetime
-from typing import Optional, Dict, Union, Any
-
-import pytz
-
-logger = logging.getLogger(__name__)
-
-_empty_map = {}
-
-
-# pylint: disable=too-many-instance-attributes
-class BaseQueryContext:
- local_tz: pytz.timezone
-
- def __init__(self,
- settings: Optional[Dict[str, Any]] = None,
- query_formats: Optional[Dict[str, str]] = None,
- column_formats: Optional[Dict[str, Union[str, Dict[str, str]]]] = None,
- encoding: Optional[str] = None,
- use_extended_dtypes: bool = False,
- use_numpy: bool = False):
- self.settings = settings or {}
- if query_formats is None:
- self.type_formats = _empty_map
- else:
- self.type_formats = {re.compile(type_name.replace('*', '.*'), re.IGNORECASE): fmt
- for type_name, fmt in query_formats.items()}
- if column_formats is None:
- self.col_simple_formats = _empty_map
- self.col_type_formats = _empty_map
- else:
- self.col_simple_formats = {col_name: fmt for col_name, fmt in column_formats.items() if
- isinstance(fmt, str)}
- self.col_type_formats = {}
- for col_name, fmt in column_formats.items():
- if not isinstance(fmt, str):
- self.col_type_formats[col_name] = {re.compile(type_name.replace('*', '.*'), re.IGNORECASE): fmt
- for type_name, fmt in fmt.items()}
- self.query_formats = query_formats or {}
- self.column_formats = column_formats or {}
- self.encoding = encoding
- self.use_numpy = use_numpy
- self.use_extended_dtypes = use_extended_dtypes
- self._active_col_fmt = None
- self._active_col_type_fmts = _empty_map
-
- def start_column(self, name: str):
- self._active_col_fmt = self.col_simple_formats.get(name)
- self._active_col_type_fmts = self.col_type_formats.get(name, _empty_map)
-
- def active_fmt(self, ch_type):
- if self._active_col_fmt:
- return self._active_col_fmt
- for type_pattern, fmt in self._active_col_type_fmts.items():
- if type_pattern.match(ch_type):
- return fmt
- for type_pattern, fmt in self.type_formats.items():
- if type_pattern.match(ch_type):
- return fmt
- return None
-
-
-def _init_context_cls():
- local_tz = datetime.now().astimezone().tzinfo
- if local_tz.tzname(datetime.now()) in ('UTC', 'GMT', 'Universal', 'GMT-0', 'Zulu', 'Greenwich'):
- local_tz = pytz.UTC
- BaseQueryContext.local_tz = local_tz
-
-
-_init_context_cls()
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/faiss/contrib/ondisk.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/faiss/contrib/ondisk.py
deleted file mode 100644
index 26a95f44f5b36e3400e486c8d82cd0759b18d8ae..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/faiss/contrib/ondisk.py
+++ /dev/null
@@ -1,59 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-from typing import List
-import faiss
-import logging
-
-LOG = logging.getLogger(__name__)
-
-
-def merge_ondisk(
- trained_index: faiss.Index, shard_fnames: List[str], ivfdata_fname: str
-) -> None:
- """Add the contents of the indexes stored in shard_fnames into the index
- trained_index. The on-disk data is stored in ivfdata_fname"""
- assert not isinstance(
- trained_index, faiss.IndexIVFPQR
- ), "IndexIVFPQR is not supported as an on disk index."
- # merge the images into an on-disk index
- # first load the inverted lists
- ivfs = []
- for fname in shard_fnames:
- # the IO_FLAG_MMAP is to avoid actually loading the data thus
- # the total size of the inverted lists can exceed the
- # available RAM
- LOG.info("read " + fname)
- index = faiss.read_index(fname, faiss.IO_FLAG_MMAP)
- index_ivf = faiss.extract_index_ivf(index)
- ivfs.append(index_ivf.invlists)
-
- # avoid that the invlists get deallocated with the index
- index_ivf.own_invlists = False
-
- # construct the output index
- index = trained_index
- index_ivf = faiss.extract_index_ivf(index)
-
- assert index.ntotal == 0, "works only on empty index"
-
- # prepare the output inverted lists. They will be written
- # to merged_index.ivfdata
- invlists = faiss.OnDiskInvertedLists(
- index_ivf.nlist, index_ivf.code_size, ivfdata_fname
- )
-
- # merge all the inverted lists
- ivf_vector = faiss.InvertedListsPtrVector()
- for ivf in ivfs:
- ivf_vector.push_back(ivf)
-
- LOG.info("merge %d inverted lists " % ivf_vector.size())
- ntotal = invlists.merge_from(ivf_vector.data(), ivf_vector.size())
-
- # now replace the inverted lists in the output index
- index.ntotal = index_ivf.ntotal = ntotal
- index_ivf.replace_invlists(invlists, True)
- invlists.this.disown()
diff --git a/spaces/cihyFjudo/fairness-paper-search/Bol Bachchan Dual Audio Eng Hindi 720p REPACK Download In Kickass Torrent Geerorlo.md b/spaces/cihyFjudo/fairness-paper-search/Bol Bachchan Dual Audio Eng Hindi 720p REPACK Download In Kickass Torrent Geerorlo.md
deleted file mode 100644
index 650480d7452aed6afe67282efdcc95c7efe80971..0000000000000000000000000000000000000000
--- a/spaces/cihyFjudo/fairness-paper-search/Bol Bachchan Dual Audio Eng Hindi 720p REPACK Download In Kickass Torrent Geerorlo.md
+++ /dev/null
@@ -1,6 +0,0 @@
-Bol Bachchan Dual Audio Eng Hindi 720p Download In Kickass Torrent geerorlo
Download File ☆☆☆ https://tinurli.com/2uwkK1
-
- aaccfb2cb3
-
-
-
diff --git a/spaces/cihyFjudo/fairness-paper-search/CZECH HUNTER 60.md b/spaces/cihyFjudo/fairness-paper-search/CZECH HUNTER 60.md
deleted file mode 100644
index e622813d8c47f4d31eb91a96d67e242ad70674a0..0000000000000000000000000000000000000000
--- a/spaces/cihyFjudo/fairness-paper-search/CZECH HUNTER 60.md
+++ /dev/null
@@ -1,6 +0,0 @@
-CZECH HUNTER 60
Download Zip ⚡ https://tinurli.com/2uwiKI
-
- aaccfb2cb3
-
-
-
diff --git a/spaces/cihyFjudo/fairness-paper-search/How to Find and Download Korean Movies With Tagalog Dubbed In Torrent for Free.md b/spaces/cihyFjudo/fairness-paper-search/How to Find and Download Korean Movies With Tagalog Dubbed In Torrent for Free.md
deleted file mode 100644
index 39f081741f18fdc54832764e9abdc70af273af32..0000000000000000000000000000000000000000
--- a/spaces/cihyFjudo/fairness-paper-search/How to Find and Download Korean Movies With Tagalog Dubbed In Torrent for Free.md
+++ /dev/null
@@ -1,5 +0,0 @@
-
-Although YouTube is the largest video sharing platform in the world, you might be surprised by why YouTube is on the list. In fact, YouTube also offers tons of free Pinoy movies for online watching, especially channels like VIVA Films, ABS-CBN Star Cinema and Regal Entertainment, Inc. However, if you want to download Pinoy movies, you have to subscribe to a premium membership. Fortunately, YouTube offers a 4-month free trial period, during which all downloads will be free. Also, you can refer to the next section to download YouTube videos without subscription.
-Korean Movies With Tagalog Dubbed Download In Torrent
Download Zip - https://tinurli.com/2uwhF7
aaccfb2cb3
-
-
\ No newline at end of file
diff --git a/spaces/cihyFjudo/fairness-paper-search/Oxycube For Nokia S40 A Must-Have Software for Nokia Users Who Want to Customize Their Phones Look and Feel.md b/spaces/cihyFjudo/fairness-paper-search/Oxycube For Nokia S40 A Must-Have Software for Nokia Users Who Want to Customize Their Phones Look and Feel.md
deleted file mode 100644
index 2be6c1556d939ee8a50c998cb53aea0f0361d77d..0000000000000000000000000000000000000000
--- a/spaces/cihyFjudo/fairness-paper-search/Oxycube For Nokia S40 A Must-Have Software for Nokia Users Who Want to Customize Their Phones Look and Feel.md
+++ /dev/null
@@ -1,6 +0,0 @@
-Oxycube For Nokia S40
Download File ->>> https://tinurli.com/2uwhBE
-
- aaccfb2cb3
-
-
-
diff --git a/spaces/cihyFjudo/fairness-paper-search/Sex POV Daddy Blowjobs... [PORTABLE].md b/spaces/cihyFjudo/fairness-paper-search/Sex POV Daddy Blowjobs... [PORTABLE].md
deleted file mode 100644
index b7b1c8c676781a90c61123dea9e92e446ea98d08..0000000000000000000000000000000000000000
--- a/spaces/cihyFjudo/fairness-paper-search/Sex POV Daddy Blowjobs... [PORTABLE].md
+++ /dev/null
@@ -1,6 +0,0 @@
-Sex POV daddy blowjobs...
Download –––––>>> https://tinurli.com/2uwhKc
-
- aaccfb2cb3
-
-
-
diff --git a/spaces/cihyFjudo/fairness-paper-search/Solucionario Principios De Operaciones Unitarias Alan Foust 110.md b/spaces/cihyFjudo/fairness-paper-search/Solucionario Principios De Operaciones Unitarias Alan Foust 110.md
deleted file mode 100644
index 613d7e119d43666ca99fe174c9afc8c2e3bf660c..0000000000000000000000000000000000000000
--- a/spaces/cihyFjudo/fairness-paper-search/Solucionario Principios De Operaciones Unitarias Alan Foust 110.md
+++ /dev/null
@@ -1,10 +0,0 @@
-
-Libro Foust Operaciones Unitarias Pdf - astiane.comPrincipios de Operaciones Unitarias Alan S.. Foust, Leonard A.. Wenzel, .. Descargar Libro y Solucionario de Principios de Operaciones Unitarias 2da Edicion .astiane.com/view/libro-foust-operaciones-unitarias-pdfHealth & BeautyDescargar Gratis en PDF Libro y Solucionario de Transferencia de Calor y Masa .. Principios de Operaciones Unitarias Alan S. -de-operaciones-unitarias...Principios de Operaciones Unitarias 2da Edicion Alan s.Principios de Operaciones Unitarias 2da Edicion Alan s.. Foust - Ebook download as PDF File (.pdf), Text File (.txt) or read book online. -de...Solucionario Principios De Operaciones Unitarias Alan .Subject: Solucionario Principios De Operaciones .. Solucionario Principios De Operaciones .. Solucionario Principios De Operaciones Unitarias Alan .www.voy.com/8547/54.htmlsolucionario geankoplis procesos de transporte y .Libro Anterior Procesos de Transporte y Operaciones .. Ese no es el solucionario de .. de la zona pdf alan foust principios operaciones unitarias pdf libros .millingequipment.co/Feb-06/solucionario-geankoplis-procesos-de...Principios de Operaciones Unitarias Alan Foust, Leonard .Principios de Operaciones Unitarias Alan Foust, .. 6 Operaciones de Multietapas a .. Solucionario 6ta .wwwblogfippuni.blogspot.com/2011/09/principios-de-operaciones...Libros de Alan S.El tratamiento que se les da en este libro a las operaciones unitarias, enfatiza los principios cientficos sobre los que -s-foust-2EL SOLUCIONARIO - Principios de Operaciones Unitarias .Principios de Operaciones Unitarias - Alan S. de Operaciones Unitarias 2da Edicion Alan s .Descargar Libro de Principios de Operaciones Unitarias 2da Edicion Alan s.. Foust, Leonard A.. Wenzel, Curtis w.librosysolucionarios.net/principios-de-operaciones-unitarias-2da...Operaciones Unitarias en Ingenieria Quimica Mccabe 6 Ed .Operaciones Unitarias en Ingenieria Quimica .. Operaciones Unitarias en Ingenieria Quimica Mccabe 6 .. Solucionario Procesos de Transporte y Principios de . -Unitarias-en... 7286bcadf1
-solucionario principios de operaciones unitarias alan foust.zip · Webroot SecureAnywhere Antivirus 2020 Crack Serial Key · Portable Microsoft .... Logix Pro 500 Plc Simulator Crack >> Plc Simulator Logixpro Allen Bradley (I, Logix ... solucionario principios de operaciones unitarias alan foust.zip.
-Solucionario Principios De Operaciones Unitarias Alan Foust | 110
Download File === https://tinurli.com/2uwkHW
-HPLA PUEDEN PORFAVOR SUBIR EL SOLUCIONARIO DE PRINCIPIOS DE OPERACINES UNITARIAS DE ALAN FOUST.. New York .... Solucionario Operaciones Unitarias Alan Foust 1 Favor si alguien tiene el solucionarios,.. 9 Nov 2012 . Principios de Operaciones Unitarias Alan S. Foust, .... cogniview pdf2xl enterprise crack keygen torrent car insurance forums solucionario principios de operaciones unitarias alan foust.zip. 34b41eb7bc. 4 / 5 .... wilcom 2006 sp4 r2 crack.29 · solucionario principios de operaciones unitarias alan foust.zip · squishing nemo mishka. Tags: lego island 2 cd ... HD Online Player (Don 2 Eng Sub 720p Movies)
-El tratamiento que se les da en este libro a las operaciones unitarias, enfatiza los principios científicos sobre los que se basan las operaciones y agrupa aquellas que tienen bases físicas similares para que puedan analizarse juntas.
-Con objeto de mantener la claridad de la presentación a un nivel elemental, es común omitir el refinamiento de los modelos físicos y las expresiones matemáticas elaboradas para un riguroso tratamiento de situaciones complejas, y con el propósito de enfatizar las similitudes que existen entre diversas operaciones unitarias, la descripción de los equipos y los métodos de cálculo especializados se presenta en forma condensada.
-Comedy full movie on .... Charlie (2015) ... Solucionario Principios De Operaciones Unitarias Alan Foust. Exceptional Over Ella Descubre Prov.. Alguien tiene el solucionario de principio de operaciones unitarias del foust ... Exceptional Over Ella Descubre Prov ->>->>->> DOWNLOAD Principios de ... MacOSXLionServer1071dmg
aaccfb2cb3
-
-
\ No newline at end of file
diff --git a/spaces/cihyFjudo/fairness-paper-search/Tum Se Achcha Kaun Hai HD A Must-Watch Movie for Bollywood Lovers.md b/spaces/cihyFjudo/fairness-paper-search/Tum Se Achcha Kaun Hai HD A Must-Watch Movie for Bollywood Lovers.md
deleted file mode 100644
index c22b45f2303d09a0b6c304ec1bfb2baeecccda80..0000000000000000000000000000000000000000
--- a/spaces/cihyFjudo/fairness-paper-search/Tum Se Achcha Kaun Hai HD A Must-Watch Movie for Bollywood Lovers.md
+++ /dev/null
@@ -1,6 +0,0 @@
-
-Adipurush full movie download is available in Hindi on Filmyhit, Moviesflix, Filmywap and Mp4moviez in Hindi dubbed. Adipurush Movie Download Hindi Filmyzilla, Adipurush Full Movie Download, Adipurush Movie Download (2022) 480p 720p 1080p,
-Adipurush full movie in Hindi free download on Pagalmovies & Pagalworld in 1080p. PagalMovies & Pagalworld may be a piracy website to download Movies HD, Hindi Movies, and PagalMovies Telugu Tamil online lawlessly at no cost to its users. PagalMovies website permits its users to observe and download movies from its PagalMovies com, Pagalworld website for free.
-movies hd 1080p full Tum Se Achcha Kaun Hai hd
Download Zip ✓✓✓ https://tinurli.com/2uwiSE
aaccfb2cb3
-
-
\ No newline at end of file
diff --git a/spaces/clarin-pl/datasets-explorer/clarin_datasets/utils.py b/spaces/clarin-pl/datasets-explorer/clarin_datasets/utils.py
deleted file mode 100644
index f9ca52eee5e86200adfee7c1777569d026b87bc0..0000000000000000000000000000000000000000
--- a/spaces/clarin-pl/datasets-explorer/clarin_datasets/utils.py
+++ /dev/null
@@ -1,70 +0,0 @@
-import re
-from typing import List
-
-from embeddings.embedding.auto_flair import AutoFlairDocumentEmbedding
-from flair.data import Sentence
-from numpy import typing as nt
-from unidecode import unidecode
-
-embedding = AutoFlairDocumentEmbedding.from_hub("clarin-pl/word2vec-kgr10")
-
-PLOT_COLOR_PALETTE = [
- "#FAEBD7",
- "#00FFFF",
- "#7FFFD4",
- "#000000",
- "#0000FF",
- "#8A2BE2",
- "#A52A2A",
- "#DEB887",
- "#5F9EA0",
- "#7FFF00",
- "#D2691E",
- "#FF7F50",
- "#6495ED",
- "#FFF8DC",
- "#DC143C",
- "#00FFFF",
- "#00008B",
- "#008B8B",
- "#B8860B",
- "#A9A9A9",
- "#006400",
- "#BDB76B",
- "#8B008B",
- "#556B2F",
- "#FF8C00",
- "#9932CC",
- "#8B0000",
- "#E9967A",
- "#8FBC8F",
- "#2F4F4F",
- "#00CED1",
- "#FFD700",
- "#DAA520",
- "#808080",
- "#FF69B4",
- "#4B0082",
- "#CD5C5C",
- "#7CFC00",
- "#F08080",
- "#66CDAA",
-]
-
-
-def flatten_list(main_list: List[List]) -> List:
- return [item for sublist in main_list for item in sublist]
-
-
-def count_num_of_characters(text: str) -> int:
- return len(re.sub(r"[^a-zA-Z]", "", unidecode(text)))
-
-
-def count_num_of_words(text: str) -> int:
- return len(re.sub(r"[^a-zA-Z ]", "", unidecode(text)).split(" "))
-
-
-def embed_sentence(sentence: str) -> nt.NDArray:
- sentence = Sentence(sentence)
- embedding.embed([sentence])
- return sentence.embedding.numpy()
diff --git a/spaces/cncanon/chud/README.md b/spaces/cncanon/chud/README.md
deleted file mode 100644
index 1bfe9faab27353cc39c4f9a7fca3b48f53b04c2c..0000000000000000000000000000000000000000
--- a/spaces/cncanon/chud/README.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Chud
-emoji: 🦀
-colorFrom: green
-colorTo: pink
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/codeparrot/apps_metric/tests.py b/spaces/codeparrot/apps_metric/tests.py
deleted file mode 100644
index 8ee99c4c8a7900319c32594b7113e4c411852605..0000000000000000000000000000000000000000
--- a/spaces/codeparrot/apps_metric/tests.py
+++ /dev/null
@@ -1,14 +0,0 @@
-import json
-from evaluate import load
-
-solution_sample1 = json.load(open("test_examples/solutions_problem_1.json", "r"))
-solution_sample2 = json.load(open("test_examples/solutions_problem_2.json", "r"))
-single_solutions = [solution_sample1[:1], solution_sample2[:1]]
-multiple_solutions = [solution_sample1[:3], solution_sample2[:3]]
-
-metric = load("codeparrot/apps_metric")
-result_1 = metric.compute(predictions=single_solutions, level="all")
-result_2 = metric.compute(predictions=multiple_solutions, level="all", k_list=[1, 2, 3])
-
-assert result_1 == {'avg_accuracy': 1.0, 'strict_accuracy': 1.0, 'pass_at_k': None}
-assert result_2 == {'avg_accuracy': None, 'strict_accuracy': None, 'pass_at_k': {'pass@1': 1.0, 'pass@2': 1.0, 'pass@3': 1.0}}
\ No newline at end of file
diff --git a/spaces/colakin/video-generater/public/ffmpeg/fftools/ffprobe.c b/spaces/colakin/video-generater/public/ffmpeg/fftools/ffprobe.c
deleted file mode 100644
index 6e72c37721be5aa1a908962379457e560c522bea..0000000000000000000000000000000000000000
--- a/spaces/colakin/video-generater/public/ffmpeg/fftools/ffprobe.c
+++ /dev/null
@@ -1,4232 +0,0 @@
-/*
- * Copyright (c) 2007-2010 Stefano Sabatini
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * simple media prober based on the FFmpeg libraries
- */
-
-#include "config.h"
-#include "libavutil/ffversion.h"
-
-#include
-#include
-
-#include "libavformat/avformat.h"
-#include "libavformat/version.h"
-#include "libavcodec/avcodec.h"
-#include "libavcodec/version.h"
-#include "libavutil/ambient_viewing_environment.h"
-#include "libavutil/avassert.h"
-#include "libavutil/avstring.h"
-#include "libavutil/bprint.h"
-#include "libavutil/channel_layout.h"
-#include "libavutil/display.h"
-#include "libavutil/hash.h"
-#include "libavutil/hdr_dynamic_metadata.h"
-#include "libavutil/mastering_display_metadata.h"
-#include "libavutil/hdr_dynamic_vivid_metadata.h"
-#include "libavutil/dovi_meta.h"
-#include "libavutil/opt.h"
-#include "libavutil/pixdesc.h"
-#include "libavutil/spherical.h"
-#include "libavutil/stereo3d.h"
-#include "libavutil/dict.h"
-#include "libavutil/intreadwrite.h"
-#include "libavutil/libm.h"
-#include "libavutil/parseutils.h"
-#include "libavutil/timecode.h"
-#include "libavutil/timestamp.h"
-#include "libavdevice/avdevice.h"
-#include "libavdevice/version.h"
-#include "libswscale/swscale.h"
-#include "libswscale/version.h"
-#include "libswresample/swresample.h"
-#include "libswresample/version.h"
-#include "libpostproc/postprocess.h"
-#include "libpostproc/version.h"
-#include "libavfilter/version.h"
-#include "cmdutils.h"
-#include "opt_common.h"
-
-#include "libavutil/thread.h"
-
-#if !HAVE_THREADS
-# ifdef pthread_mutex_lock
-# undef pthread_mutex_lock
-# endif
-# define pthread_mutex_lock(a) do{}while(0)
-# ifdef pthread_mutex_unlock
-# undef pthread_mutex_unlock
-# endif
-# define pthread_mutex_unlock(a) do{}while(0)
-#endif
-
-// attached as opaque_ref to packets/frames
-typedef struct FrameData {
- int64_t pkt_pos;
- int pkt_size;
-} FrameData;
-
-typedef struct InputStream {
- AVStream *st;
-
- AVCodecContext *dec_ctx;
-} InputStream;
-
-typedef struct InputFile {
- AVFormatContext *fmt_ctx;
-
- InputStream *streams;
- int nb_streams;
-} InputFile;
-
-const char program_name[] = "ffprobe";
-const int program_birth_year = 2007;
-
-static int do_bitexact = 0;
-static int do_count_frames = 0;
-static int do_count_packets = 0;
-static int do_read_frames = 0;
-static int do_read_packets = 0;
-static int do_show_chapters = 0;
-static int do_show_error = 0;
-static int do_show_format = 0;
-static int do_show_frames = 0;
-static int do_show_packets = 0;
-static int do_show_programs = 0;
-static int do_show_streams = 0;
-static int do_show_stream_disposition = 0;
-static int do_show_data = 0;
-static int do_show_program_version = 0;
-static int do_show_library_versions = 0;
-static int do_show_pixel_formats = 0;
-static int do_show_pixel_format_flags = 0;
-static int do_show_pixel_format_components = 0;
-static int do_show_log = 0;
-
-static int do_show_chapter_tags = 0;
-static int do_show_format_tags = 0;
-static int do_show_frame_tags = 0;
-static int do_show_program_tags = 0;
-static int do_show_stream_tags = 0;
-static int do_show_packet_tags = 0;
-
-static int show_value_unit = 0;
-static int use_value_prefix = 0;
-static int use_byte_value_binary_prefix = 0;
-static int use_value_sexagesimal_format = 0;
-static int show_private_data = 1;
-
-#define SHOW_OPTIONAL_FIELDS_AUTO -1
-#define SHOW_OPTIONAL_FIELDS_NEVER 0
-#define SHOW_OPTIONAL_FIELDS_ALWAYS 1
-static int show_optional_fields = SHOW_OPTIONAL_FIELDS_AUTO;
-
-static char *print_format;
-static char *stream_specifier;
-static char *show_data_hash;
-
-typedef struct ReadInterval {
- int id; ///< identifier
- int64_t start, end; ///< start, end in second/AV_TIME_BASE units
- int has_start, has_end;
- int start_is_offset, end_is_offset;
- int duration_frames;
-} ReadInterval;
-
-static ReadInterval *read_intervals;
-static int read_intervals_nb = 0;
-
-static int find_stream_info = 1;
-
-/* section structure definition */
-
-#define SECTION_MAX_NB_CHILDREN 10
-
-struct section {
- int id; ///< unique id identifying a section
- const char *name;
-
-#define SECTION_FLAG_IS_WRAPPER 1 ///< the section only contains other sections, but has no data at its own level
-#define SECTION_FLAG_IS_ARRAY 2 ///< the section contains an array of elements of the same type
-#define SECTION_FLAG_HAS_VARIABLE_FIELDS 4 ///< the section may contain a variable number of fields with variable keys.
- /// For these sections the element_name field is mandatory.
- int flags;
- int children_ids[SECTION_MAX_NB_CHILDREN+1]; ///< list of children section IDS, terminated by -1
- const char *element_name; ///< name of the contained element, if provided
- const char *unique_name; ///< unique section name, in case the name is ambiguous
- AVDictionary *entries_to_show;
- int show_all_entries;
-};
-
-typedef enum {
- SECTION_ID_NONE = -1,
- SECTION_ID_CHAPTER,
- SECTION_ID_CHAPTER_TAGS,
- SECTION_ID_CHAPTERS,
- SECTION_ID_ERROR,
- SECTION_ID_FORMAT,
- SECTION_ID_FORMAT_TAGS,
- SECTION_ID_FRAME,
- SECTION_ID_FRAMES,
- SECTION_ID_FRAME_TAGS,
- SECTION_ID_FRAME_SIDE_DATA_LIST,
- SECTION_ID_FRAME_SIDE_DATA,
- SECTION_ID_FRAME_SIDE_DATA_TIMECODE_LIST,
- SECTION_ID_FRAME_SIDE_DATA_TIMECODE,
- SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST,
- SECTION_ID_FRAME_SIDE_DATA_COMPONENT,
- SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST,
- SECTION_ID_FRAME_SIDE_DATA_PIECE,
- SECTION_ID_FRAME_LOG,
- SECTION_ID_FRAME_LOGS,
- SECTION_ID_LIBRARY_VERSION,
- SECTION_ID_LIBRARY_VERSIONS,
- SECTION_ID_PACKET,
- SECTION_ID_PACKET_TAGS,
- SECTION_ID_PACKETS,
- SECTION_ID_PACKETS_AND_FRAMES,
- SECTION_ID_PACKET_SIDE_DATA_LIST,
- SECTION_ID_PACKET_SIDE_DATA,
- SECTION_ID_PIXEL_FORMAT,
- SECTION_ID_PIXEL_FORMAT_FLAGS,
- SECTION_ID_PIXEL_FORMAT_COMPONENT,
- SECTION_ID_PIXEL_FORMAT_COMPONENTS,
- SECTION_ID_PIXEL_FORMATS,
- SECTION_ID_PROGRAM_STREAM_DISPOSITION,
- SECTION_ID_PROGRAM_STREAM_TAGS,
- SECTION_ID_PROGRAM,
- SECTION_ID_PROGRAM_STREAMS,
- SECTION_ID_PROGRAM_STREAM,
- SECTION_ID_PROGRAM_TAGS,
- SECTION_ID_PROGRAM_VERSION,
- SECTION_ID_PROGRAMS,
- SECTION_ID_ROOT,
- SECTION_ID_STREAM,
- SECTION_ID_STREAM_DISPOSITION,
- SECTION_ID_STREAMS,
- SECTION_ID_STREAM_TAGS,
- SECTION_ID_STREAM_SIDE_DATA_LIST,
- SECTION_ID_STREAM_SIDE_DATA,
- SECTION_ID_SUBTITLE,
-} SectionID;
-
-static struct section sections[] = {
- [SECTION_ID_CHAPTERS] = { SECTION_ID_CHAPTERS, "chapters", SECTION_FLAG_IS_ARRAY, { SECTION_ID_CHAPTER, -1 } },
- [SECTION_ID_CHAPTER] = { SECTION_ID_CHAPTER, "chapter", 0, { SECTION_ID_CHAPTER_TAGS, -1 } },
- [SECTION_ID_CHAPTER_TAGS] = { SECTION_ID_CHAPTER_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "chapter_tags" },
- [SECTION_ID_ERROR] = { SECTION_ID_ERROR, "error", 0, { -1 } },
- [SECTION_ID_FORMAT] = { SECTION_ID_FORMAT, "format", 0, { SECTION_ID_FORMAT_TAGS, -1 } },
- [SECTION_ID_FORMAT_TAGS] = { SECTION_ID_FORMAT_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "format_tags" },
- [SECTION_ID_FRAMES] = { SECTION_ID_FRAMES, "frames", SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME, SECTION_ID_SUBTITLE, -1 } },
- [SECTION_ID_FRAME] = { SECTION_ID_FRAME, "frame", 0, { SECTION_ID_FRAME_TAGS, SECTION_ID_FRAME_SIDE_DATA_LIST, SECTION_ID_FRAME_LOGS, -1 } },
- [SECTION_ID_FRAME_TAGS] = { SECTION_ID_FRAME_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "frame_tags" },
- [SECTION_ID_FRAME_SIDE_DATA_LIST] ={ SECTION_ID_FRAME_SIDE_DATA_LIST, "side_data_list", SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME_SIDE_DATA, -1 }, .element_name = "side_data", .unique_name = "frame_side_data_list" },
- [SECTION_ID_FRAME_SIDE_DATA] = { SECTION_ID_FRAME_SIDE_DATA, "side_data", 0, { SECTION_ID_FRAME_SIDE_DATA_TIMECODE_LIST, SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST, -1 }, .unique_name = "frame_side_data" },
- [SECTION_ID_FRAME_SIDE_DATA_TIMECODE_LIST] = { SECTION_ID_FRAME_SIDE_DATA_TIMECODE_LIST, "timecodes", SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME_SIDE_DATA_TIMECODE, -1 } },
- [SECTION_ID_FRAME_SIDE_DATA_TIMECODE] = { SECTION_ID_FRAME_SIDE_DATA_TIMECODE, "timecode", 0, { -1 } },
- [SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST] = { SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST, "components", SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME_SIDE_DATA_COMPONENT, -1 } },
- [SECTION_ID_FRAME_SIDE_DATA_COMPONENT] = { SECTION_ID_FRAME_SIDE_DATA_COMPONENT, "component", 0, { SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST, -1 } },
- [SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST] = { SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST, "pieces", SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME_SIDE_DATA_PIECE, -1 } },
- [SECTION_ID_FRAME_SIDE_DATA_PIECE] = { SECTION_ID_FRAME_SIDE_DATA_PIECE, "section", 0, { -1 } },
- [SECTION_ID_FRAME_LOGS] = { SECTION_ID_FRAME_LOGS, "logs", SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME_LOG, -1 } },
- [SECTION_ID_FRAME_LOG] = { SECTION_ID_FRAME_LOG, "log", 0, { -1 }, },
- [SECTION_ID_LIBRARY_VERSIONS] = { SECTION_ID_LIBRARY_VERSIONS, "library_versions", SECTION_FLAG_IS_ARRAY, { SECTION_ID_LIBRARY_VERSION, -1 } },
- [SECTION_ID_LIBRARY_VERSION] = { SECTION_ID_LIBRARY_VERSION, "library_version", 0, { -1 } },
- [SECTION_ID_PACKETS] = { SECTION_ID_PACKETS, "packets", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PACKET, -1} },
- [SECTION_ID_PACKETS_AND_FRAMES] = { SECTION_ID_PACKETS_AND_FRAMES, "packets_and_frames", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PACKET, -1} },
- [SECTION_ID_PACKET] = { SECTION_ID_PACKET, "packet", 0, { SECTION_ID_PACKET_TAGS, SECTION_ID_PACKET_SIDE_DATA_LIST, -1 } },
- [SECTION_ID_PACKET_TAGS] = { SECTION_ID_PACKET_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "packet_tags" },
- [SECTION_ID_PACKET_SIDE_DATA_LIST] ={ SECTION_ID_PACKET_SIDE_DATA_LIST, "side_data_list", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PACKET_SIDE_DATA, -1 }, .element_name = "side_data", .unique_name = "packet_side_data_list" },
- [SECTION_ID_PACKET_SIDE_DATA] = { SECTION_ID_PACKET_SIDE_DATA, "side_data", 0, { -1 }, .unique_name = "packet_side_data" },
- [SECTION_ID_PIXEL_FORMATS] = { SECTION_ID_PIXEL_FORMATS, "pixel_formats", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PIXEL_FORMAT, -1 } },
- [SECTION_ID_PIXEL_FORMAT] = { SECTION_ID_PIXEL_FORMAT, "pixel_format", 0, { SECTION_ID_PIXEL_FORMAT_FLAGS, SECTION_ID_PIXEL_FORMAT_COMPONENTS, -1 } },
- [SECTION_ID_PIXEL_FORMAT_FLAGS] = { SECTION_ID_PIXEL_FORMAT_FLAGS, "flags", 0, { -1 }, .unique_name = "pixel_format_flags" },
- [SECTION_ID_PIXEL_FORMAT_COMPONENTS] = { SECTION_ID_PIXEL_FORMAT_COMPONENTS, "components", SECTION_FLAG_IS_ARRAY, {SECTION_ID_PIXEL_FORMAT_COMPONENT, -1 }, .unique_name = "pixel_format_components" },
- [SECTION_ID_PIXEL_FORMAT_COMPONENT] = { SECTION_ID_PIXEL_FORMAT_COMPONENT, "component", 0, { -1 } },
- [SECTION_ID_PROGRAM_STREAM_DISPOSITION] = { SECTION_ID_PROGRAM_STREAM_DISPOSITION, "disposition", 0, { -1 }, .unique_name = "program_stream_disposition" },
- [SECTION_ID_PROGRAM_STREAM_TAGS] = { SECTION_ID_PROGRAM_STREAM_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "program_stream_tags" },
- [SECTION_ID_PROGRAM] = { SECTION_ID_PROGRAM, "program", 0, { SECTION_ID_PROGRAM_TAGS, SECTION_ID_PROGRAM_STREAMS, -1 } },
- [SECTION_ID_PROGRAM_STREAMS] = { SECTION_ID_PROGRAM_STREAMS, "streams", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PROGRAM_STREAM, -1 }, .unique_name = "program_streams" },
- [SECTION_ID_PROGRAM_STREAM] = { SECTION_ID_PROGRAM_STREAM, "stream", 0, { SECTION_ID_PROGRAM_STREAM_DISPOSITION, SECTION_ID_PROGRAM_STREAM_TAGS, -1 }, .unique_name = "program_stream" },
- [SECTION_ID_PROGRAM_TAGS] = { SECTION_ID_PROGRAM_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "program_tags" },
- [SECTION_ID_PROGRAM_VERSION] = { SECTION_ID_PROGRAM_VERSION, "program_version", 0, { -1 } },
- [SECTION_ID_PROGRAMS] = { SECTION_ID_PROGRAMS, "programs", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PROGRAM, -1 } },
- [SECTION_ID_ROOT] = { SECTION_ID_ROOT, "root", SECTION_FLAG_IS_WRAPPER,
- { SECTION_ID_CHAPTERS, SECTION_ID_FORMAT, SECTION_ID_FRAMES, SECTION_ID_PROGRAMS, SECTION_ID_STREAMS,
- SECTION_ID_PACKETS, SECTION_ID_ERROR, SECTION_ID_PROGRAM_VERSION, SECTION_ID_LIBRARY_VERSIONS,
- SECTION_ID_PIXEL_FORMATS, -1} },
- [SECTION_ID_STREAMS] = { SECTION_ID_STREAMS, "streams", SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM, -1 } },
- [SECTION_ID_STREAM] = { SECTION_ID_STREAM, "stream", 0, { SECTION_ID_STREAM_DISPOSITION, SECTION_ID_STREAM_TAGS, SECTION_ID_STREAM_SIDE_DATA_LIST, -1 } },
- [SECTION_ID_STREAM_DISPOSITION] = { SECTION_ID_STREAM_DISPOSITION, "disposition", 0, { -1 }, .unique_name = "stream_disposition" },
- [SECTION_ID_STREAM_TAGS] = { SECTION_ID_STREAM_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "stream_tags" },
- [SECTION_ID_STREAM_SIDE_DATA_LIST] ={ SECTION_ID_STREAM_SIDE_DATA_LIST, "side_data_list", SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM_SIDE_DATA, -1 }, .element_name = "side_data", .unique_name = "stream_side_data_list" },
- [SECTION_ID_STREAM_SIDE_DATA] = { SECTION_ID_STREAM_SIDE_DATA, "side_data", 0, { -1 }, .unique_name = "stream_side_data" },
- [SECTION_ID_SUBTITLE] = { SECTION_ID_SUBTITLE, "subtitle", 0, { -1 } },
-};
-
-static const OptionDef *options;
-
-/* FFprobe context */
-static const char *input_filename;
-static const char *print_input_filename;
-static const AVInputFormat *iformat = NULL;
-static const char *output_filename = NULL;
-
-static struct AVHashContext *hash;
-
-static const struct {
- double bin_val;
- double dec_val;
- const char *bin_str;
- const char *dec_str;
-} si_prefixes[] = {
- { 1.0, 1.0, "", "" },
- { 1.024e3, 1e3, "Ki", "K" },
- { 1.048576e6, 1e6, "Mi", "M" },
- { 1.073741824e9, 1e9, "Gi", "G" },
- { 1.099511627776e12, 1e12, "Ti", "T" },
- { 1.125899906842624e15, 1e15, "Pi", "P" },
-};
-
-static const char unit_second_str[] = "s" ;
-static const char unit_hertz_str[] = "Hz" ;
-static const char unit_byte_str[] = "byte" ;
-static const char unit_bit_per_second_str[] = "bit/s";
-
-static int nb_streams;
-static uint64_t *nb_streams_packets;
-static uint64_t *nb_streams_frames;
-static int *selected_streams;
-
-#if HAVE_THREADS
-pthread_mutex_t log_mutex;
-#endif
-typedef struct LogBuffer {
- char *context_name;
- int log_level;
- char *log_message;
- AVClassCategory category;
- char *parent_name;
- AVClassCategory parent_category;
-}LogBuffer;
-
-static LogBuffer *log_buffer;
-static int log_buffer_size;
-
-static void log_callback(void *ptr, int level, const char *fmt, va_list vl)
-{
- AVClass* avc = ptr ? *(AVClass **) ptr : NULL;
- va_list vl2;
- char line[1024];
- static int print_prefix = 1;
- void *new_log_buffer;
-
- va_copy(vl2, vl);
- av_log_default_callback(ptr, level, fmt, vl);
- av_log_format_line(ptr, level, fmt, vl2, line, sizeof(line), &print_prefix);
- va_end(vl2);
-
-#if HAVE_THREADS
- pthread_mutex_lock(&log_mutex);
-
- new_log_buffer = av_realloc_array(log_buffer, log_buffer_size + 1, sizeof(*log_buffer));
- if (new_log_buffer) {
- char *msg;
- int i;
-
- log_buffer = new_log_buffer;
- memset(&log_buffer[log_buffer_size], 0, sizeof(log_buffer[log_buffer_size]));
- log_buffer[log_buffer_size].context_name= avc ? av_strdup(avc->item_name(ptr)) : NULL;
- if (avc) {
- if (avc->get_category) log_buffer[log_buffer_size].category = avc->get_category(ptr);
- else log_buffer[log_buffer_size].category = avc->category;
- }
- log_buffer[log_buffer_size].log_level = level;
- msg = log_buffer[log_buffer_size].log_message = av_strdup(line);
- for (i=strlen(msg) - 1; i>=0 && msg[i] == '\n'; i--) {
- msg[i] = 0;
- }
- if (avc && avc->parent_log_context_offset) {
- AVClass** parent = *(AVClass ***) (((uint8_t *) ptr) +
- avc->parent_log_context_offset);
- if (parent && *parent) {
- log_buffer[log_buffer_size].parent_name = av_strdup((*parent)->item_name(parent));
- log_buffer[log_buffer_size].parent_category =
- (*parent)->get_category ? (*parent)->get_category(parent) :(*parent)->category;
- }
- }
- log_buffer_size ++;
- }
-
- pthread_mutex_unlock(&log_mutex);
-#endif
-}
-
-static void ffprobe_cleanup(int ret)
-{
- int i;
- for (i = 0; i < FF_ARRAY_ELEMS(sections); i++)
- av_dict_free(&(sections[i].entries_to_show));
-
-#if HAVE_THREADS
- pthread_mutex_destroy(&log_mutex);
-#endif
-}
-
-struct unit_value {
- union { double d; long long int i; } val;
- const char *unit;
-};
-
-static char *value_string(char *buf, int buf_size, struct unit_value uv)
-{
- double vald;
- long long int vali;
- int show_float = 0;
-
- if (uv.unit == unit_second_str) {
- vald = uv.val.d;
- show_float = 1;
- } else {
- vald = vali = uv.val.i;
- }
-
- if (uv.unit == unit_second_str && use_value_sexagesimal_format) {
- double secs;
- int hours, mins;
- secs = vald;
- mins = (int)secs / 60;
- secs = secs - mins * 60;
- hours = mins / 60;
- mins %= 60;
- snprintf(buf, buf_size, "%d:%02d:%09.6f", hours, mins, secs);
- } else {
- const char *prefix_string = "";
-
- if (use_value_prefix && vald > 1) {
- long long int index;
-
- if (uv.unit == unit_byte_str && use_byte_value_binary_prefix) {
- index = (long long int) (log2(vald)) / 10;
- index = av_clip(index, 0, FF_ARRAY_ELEMS(si_prefixes) - 1);
- vald /= si_prefixes[index].bin_val;
- prefix_string = si_prefixes[index].bin_str;
- } else {
- index = (long long int) (log10(vald)) / 3;
- index = av_clip(index, 0, FF_ARRAY_ELEMS(si_prefixes) - 1);
- vald /= si_prefixes[index].dec_val;
- prefix_string = si_prefixes[index].dec_str;
- }
- vali = vald;
- }
-
- if (show_float || (use_value_prefix && vald != (long long int)vald))
- snprintf(buf, buf_size, "%f", vald);
- else
- snprintf(buf, buf_size, "%lld", vali);
- av_strlcatf(buf, buf_size, "%s%s%s", *prefix_string || show_value_unit ? " " : "",
- prefix_string, show_value_unit ? uv.unit : "");
- }
-
- return buf;
-}
-
-/* WRITERS API */
-
-typedef struct WriterContext WriterContext;
-
-#define WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS 1
-#define WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER 2
-
-typedef enum {
- WRITER_STRING_VALIDATION_FAIL,
- WRITER_STRING_VALIDATION_REPLACE,
- WRITER_STRING_VALIDATION_IGNORE,
- WRITER_STRING_VALIDATION_NB
-} StringValidation;
-
-typedef struct Writer {
- const AVClass *priv_class; ///< private class of the writer, if any
- int priv_size; ///< private size for the writer context
- const char *name;
-
- int (*init) (WriterContext *wctx);
- void (*uninit)(WriterContext *wctx);
-
- void (*print_section_header)(WriterContext *wctx);
- void (*print_section_footer)(WriterContext *wctx);
- void (*print_integer) (WriterContext *wctx, const char *, long long int);
- void (*print_rational) (WriterContext *wctx, AVRational *q, char *sep);
- void (*print_string) (WriterContext *wctx, const char *, const char *);
- int flags; ///< a combination or WRITER_FLAG_*
-} Writer;
-
-#define SECTION_MAX_NB_LEVELS 10
-
-struct WriterContext {
- const AVClass *class; ///< class of the writer
- const Writer *writer; ///< the Writer of which this is an instance
- AVIOContext *avio; ///< the I/O context used to write
-
- void (* writer_w8)(WriterContext *wctx, int b);
- void (* writer_put_str)(WriterContext *wctx, const char *str);
- void (* writer_printf)(WriterContext *wctx, const char *fmt, ...);
-
- char *name; ///< name of this writer instance
- void *priv; ///< private data for use by the filter
-
- const struct section *sections; ///< array containing all sections
- int nb_sections; ///< number of sections
-
- int level; ///< current level, starting from 0
-
- /** number of the item printed in the given section, starting from 0 */
- unsigned int nb_item[SECTION_MAX_NB_LEVELS];
-
- /** section per each level */
- const struct section *section[SECTION_MAX_NB_LEVELS];
- AVBPrint section_pbuf[SECTION_MAX_NB_LEVELS]; ///< generic print buffer dedicated to each section,
- /// used by various writers
-
- unsigned int nb_section_packet; ///< number of the packet section in case we are in "packets_and_frames" section
- unsigned int nb_section_frame; ///< number of the frame section in case we are in "packets_and_frames" section
- unsigned int nb_section_packet_frame; ///< nb_section_packet or nb_section_frame according if is_packets_and_frames
-
- int string_validation;
- char *string_validation_replacement;
- unsigned int string_validation_utf8_flags;
-};
-
-static const char *writer_get_name(void *p)
-{
- WriterContext *wctx = p;
- return wctx->writer->name;
-}
-
-#define OFFSET(x) offsetof(WriterContext, x)
-
-static const AVOption writer_options[] = {
- { "string_validation", "set string validation mode",
- OFFSET(string_validation), AV_OPT_TYPE_INT, {.i64=WRITER_STRING_VALIDATION_REPLACE}, 0, WRITER_STRING_VALIDATION_NB-1, .unit = "sv" },
- { "sv", "set string validation mode",
- OFFSET(string_validation), AV_OPT_TYPE_INT, {.i64=WRITER_STRING_VALIDATION_REPLACE}, 0, WRITER_STRING_VALIDATION_NB-1, .unit = "sv" },
- { "ignore", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = WRITER_STRING_VALIDATION_IGNORE}, .unit = "sv" },
- { "replace", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = WRITER_STRING_VALIDATION_REPLACE}, .unit = "sv" },
- { "fail", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = WRITER_STRING_VALIDATION_FAIL}, .unit = "sv" },
- { "string_validation_replacement", "set string validation replacement string", OFFSET(string_validation_replacement), AV_OPT_TYPE_STRING, {.str=""}},
- { "svr", "set string validation replacement string", OFFSET(string_validation_replacement), AV_OPT_TYPE_STRING, {.str="\xEF\xBF\xBD"}},
- { NULL }
-};
-
-static void *writer_child_next(void *obj, void *prev)
-{
- WriterContext *ctx = obj;
- if (!prev && ctx->writer && ctx->writer->priv_class && ctx->priv)
- return ctx->priv;
- return NULL;
-}
-
-static const AVClass writer_class = {
- .class_name = "Writer",
- .item_name = writer_get_name,
- .option = writer_options,
- .version = LIBAVUTIL_VERSION_INT,
- .child_next = writer_child_next,
-};
-
-static int writer_close(WriterContext **wctx)
-{
- int i;
- int ret = 0;
-
- if (!*wctx)
- return -1;
-
- if ((*wctx)->writer->uninit)
- (*wctx)->writer->uninit(*wctx);
- for (i = 0; i < SECTION_MAX_NB_LEVELS; i++)
- av_bprint_finalize(&(*wctx)->section_pbuf[i], NULL);
- if ((*wctx)->writer->priv_class)
- av_opt_free((*wctx)->priv);
- av_freep(&((*wctx)->priv));
- av_opt_free(*wctx);
- if ((*wctx)->avio) {
- avio_flush((*wctx)->avio);
- ret = avio_close((*wctx)->avio);
- }
- av_freep(wctx);
- return ret;
-}
-
-static void bprint_bytes(AVBPrint *bp, const uint8_t *ubuf, size_t ubuf_size)
-{
- int i;
- av_bprintf(bp, "0X");
- for (i = 0; i < ubuf_size; i++)
- av_bprintf(bp, "%02X", ubuf[i]);
-}
-
-static inline void writer_w8_avio(WriterContext *wctx, int b)
-{
- avio_w8(wctx->avio, b);
-}
-
-static inline void writer_put_str_avio(WriterContext *wctx, const char *str)
-{
- avio_write(wctx->avio, str, strlen(str));
-}
-
-static inline void writer_printf_avio(WriterContext *wctx, const char *fmt, ...)
-{
- va_list ap;
-
- va_start(ap, fmt);
- avio_vprintf(wctx->avio, fmt, ap);
- va_end(ap);
-}
-
-static inline void writer_w8_printf(WriterContext *wctx, int b)
-{
- printf("%c", b);
-}
-
-static inline void writer_put_str_printf(WriterContext *wctx, const char *str)
-{
- printf("%s", str);
-}
-
-static inline void writer_printf_printf(WriterContext *wctx, const char *fmt, ...)
-{
- va_list ap;
-
- va_start(ap, fmt);
- vprintf(fmt, ap);
- va_end(ap);
-}
-
-static int writer_open(WriterContext **wctx, const Writer *writer, const char *args,
- const struct section *sections, int nb_sections, const char *output)
-{
- int i, ret = 0;
-
- if (!(*wctx = av_mallocz(sizeof(WriterContext)))) {
- ret = AVERROR(ENOMEM);
- goto fail;
- }
-
- if (!((*wctx)->priv = av_mallocz(writer->priv_size))) {
- ret = AVERROR(ENOMEM);
- goto fail;
- }
-
- (*wctx)->class = &writer_class;
- (*wctx)->writer = writer;
- (*wctx)->level = -1;
- (*wctx)->sections = sections;
- (*wctx)->nb_sections = nb_sections;
-
- av_opt_set_defaults(*wctx);
-
- if (writer->priv_class) {
- void *priv_ctx = (*wctx)->priv;
- *((const AVClass **)priv_ctx) = writer->priv_class;
- av_opt_set_defaults(priv_ctx);
- }
-
- /* convert options to dictionary */
- if (args) {
- AVDictionary *opts = NULL;
- const AVDictionaryEntry *opt = NULL;
-
- if ((ret = av_dict_parse_string(&opts, args, "=", ":", 0)) < 0) {
- av_log(*wctx, AV_LOG_ERROR, "Failed to parse option string '%s' provided to writer context\n", args);
- av_dict_free(&opts);
- goto fail;
- }
-
- while ((opt = av_dict_iterate(opts, opt))) {
- if ((ret = av_opt_set(*wctx, opt->key, opt->value, AV_OPT_SEARCH_CHILDREN)) < 0) {
- av_log(*wctx, AV_LOG_ERROR, "Failed to set option '%s' with value '%s' provided to writer context\n",
- opt->key, opt->value);
- av_dict_free(&opts);
- goto fail;
- }
- }
-
- av_dict_free(&opts);
- }
-
- /* validate replace string */
- {
- const uint8_t *p = (*wctx)->string_validation_replacement;
- const uint8_t *endp = p + strlen(p);
- while (*p) {
- const uint8_t *p0 = p;
- int32_t code;
- ret = av_utf8_decode(&code, &p, endp, (*wctx)->string_validation_utf8_flags);
- if (ret < 0) {
- AVBPrint bp;
- av_bprint_init(&bp, 0, AV_BPRINT_SIZE_AUTOMATIC);
- bprint_bytes(&bp, p0, p-p0),
- av_log(wctx, AV_LOG_ERROR,
- "Invalid UTF8 sequence %s found in string validation replace '%s'\n",
- bp.str, (*wctx)->string_validation_replacement);
- return ret;
- }
- }
- }
-
- if (!output_filename) {
- (*wctx)->writer_w8 = writer_w8_printf;
- (*wctx)->writer_put_str = writer_put_str_printf;
- (*wctx)->writer_printf = writer_printf_printf;
- } else {
- if ((ret = avio_open(&(*wctx)->avio, output, AVIO_FLAG_WRITE)) < 0) {
- av_log(*wctx, AV_LOG_ERROR,
- "Failed to open output '%s' with error: %s\n", output, av_err2str(ret));
- goto fail;
- }
- (*wctx)->writer_w8 = writer_w8_avio;
- (*wctx)->writer_put_str = writer_put_str_avio;
- (*wctx)->writer_printf = writer_printf_avio;
- }
-
- for (i = 0; i < SECTION_MAX_NB_LEVELS; i++)
- av_bprint_init(&(*wctx)->section_pbuf[i], 1, AV_BPRINT_SIZE_UNLIMITED);
-
- if ((*wctx)->writer->init)
- ret = (*wctx)->writer->init(*wctx);
- if (ret < 0)
- goto fail;
-
- return 0;
-
-fail:
- writer_close(wctx);
- return ret;
-}
-
-static inline void writer_print_section_header(WriterContext *wctx,
- int section_id)
-{
- int parent_section_id;
- wctx->level++;
- av_assert0(wctx->level < SECTION_MAX_NB_LEVELS);
- parent_section_id = wctx->level ?
- (wctx->section[wctx->level-1])->id : SECTION_ID_NONE;
-
- wctx->nb_item[wctx->level] = 0;
- wctx->section[wctx->level] = &wctx->sections[section_id];
-
- if (section_id == SECTION_ID_PACKETS_AND_FRAMES) {
- wctx->nb_section_packet = wctx->nb_section_frame =
- wctx->nb_section_packet_frame = 0;
- } else if (parent_section_id == SECTION_ID_PACKETS_AND_FRAMES) {
- wctx->nb_section_packet_frame = section_id == SECTION_ID_PACKET ?
- wctx->nb_section_packet : wctx->nb_section_frame;
- }
-
- if (wctx->writer->print_section_header)
- wctx->writer->print_section_header(wctx);
-}
-
-static inline void writer_print_section_footer(WriterContext *wctx)
-{
- int section_id = wctx->section[wctx->level]->id;
- int parent_section_id = wctx->level ?
- wctx->section[wctx->level-1]->id : SECTION_ID_NONE;
-
- if (parent_section_id != SECTION_ID_NONE)
- wctx->nb_item[wctx->level-1]++;
- if (parent_section_id == SECTION_ID_PACKETS_AND_FRAMES) {
- if (section_id == SECTION_ID_PACKET) wctx->nb_section_packet++;
- else wctx->nb_section_frame++;
- }
- if (wctx->writer->print_section_footer)
- wctx->writer->print_section_footer(wctx);
- wctx->level--;
-}
-
-static inline void writer_print_integer(WriterContext *wctx,
- const char *key, long long int val)
-{
- const struct section *section = wctx->section[wctx->level];
-
- if (section->show_all_entries || av_dict_get(section->entries_to_show, key, NULL, 0)) {
- wctx->writer->print_integer(wctx, key, val);
- wctx->nb_item[wctx->level]++;
- }
-}
-
-static inline int validate_string(WriterContext *wctx, char **dstp, const char *src)
-{
- const uint8_t *p, *endp;
- AVBPrint dstbuf;
- int invalid_chars_nb = 0, ret = 0;
-
- av_bprint_init(&dstbuf, 0, AV_BPRINT_SIZE_UNLIMITED);
-
- endp = src + strlen(src);
- for (p = (uint8_t *)src; *p;) {
- uint32_t code;
- int invalid = 0;
- const uint8_t *p0 = p;
-
- if (av_utf8_decode(&code, &p, endp, wctx->string_validation_utf8_flags) < 0) {
- AVBPrint bp;
- av_bprint_init(&bp, 0, AV_BPRINT_SIZE_AUTOMATIC);
- bprint_bytes(&bp, p0, p-p0);
- av_log(wctx, AV_LOG_DEBUG,
- "Invalid UTF-8 sequence %s found in string '%s'\n", bp.str, src);
- invalid = 1;
- }
-
- if (invalid) {
- invalid_chars_nb++;
-
- switch (wctx->string_validation) {
- case WRITER_STRING_VALIDATION_FAIL:
- av_log(wctx, AV_LOG_ERROR,
- "Invalid UTF-8 sequence found in string '%s'\n", src);
- ret = AVERROR_INVALIDDATA;
- goto end;
- break;
-
- case WRITER_STRING_VALIDATION_REPLACE:
- av_bprintf(&dstbuf, "%s", wctx->string_validation_replacement);
- break;
- }
- }
-
- if (!invalid || wctx->string_validation == WRITER_STRING_VALIDATION_IGNORE)
- av_bprint_append_data(&dstbuf, p0, p-p0);
- }
-
- if (invalid_chars_nb && wctx->string_validation == WRITER_STRING_VALIDATION_REPLACE) {
- av_log(wctx, AV_LOG_WARNING,
- "%d invalid UTF-8 sequence(s) found in string '%s', replaced with '%s'\n",
- invalid_chars_nb, src, wctx->string_validation_replacement);
- }
-
-end:
- av_bprint_finalize(&dstbuf, dstp);
- return ret;
-}
-
-#define PRINT_STRING_OPT 1
-#define PRINT_STRING_VALIDATE 2
-
-static inline int writer_print_string(WriterContext *wctx,
- const char *key, const char *val, int flags)
-{
- const struct section *section = wctx->section[wctx->level];
- int ret = 0;
-
- if (show_optional_fields == SHOW_OPTIONAL_FIELDS_NEVER ||
- (show_optional_fields == SHOW_OPTIONAL_FIELDS_AUTO
- && (flags & PRINT_STRING_OPT)
- && !(wctx->writer->flags & WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS)))
- return 0;
-
- if (section->show_all_entries || av_dict_get(section->entries_to_show, key, NULL, 0)) {
- if (flags & PRINT_STRING_VALIDATE) {
- char *key1 = NULL, *val1 = NULL;
- ret = validate_string(wctx, &key1, key);
- if (ret < 0) goto end;
- ret = validate_string(wctx, &val1, val);
- if (ret < 0) goto end;
- wctx->writer->print_string(wctx, key1, val1);
- end:
- if (ret < 0) {
- av_log(wctx, AV_LOG_ERROR,
- "Invalid key=value string combination %s=%s in section %s\n",
- key, val, section->unique_name);
- }
- av_free(key1);
- av_free(val1);
- } else {
- wctx->writer->print_string(wctx, key, val);
- }
-
- wctx->nb_item[wctx->level]++;
- }
-
- return ret;
-}
-
-static inline void writer_print_rational(WriterContext *wctx,
- const char *key, AVRational q, char sep)
-{
- AVBPrint buf;
- av_bprint_init(&buf, 0, AV_BPRINT_SIZE_AUTOMATIC);
- av_bprintf(&buf, "%d%c%d", q.num, sep, q.den);
- writer_print_string(wctx, key, buf.str, 0);
-}
-
-static void writer_print_time(WriterContext *wctx, const char *key,
- int64_t ts, const AVRational *time_base, int is_duration)
-{
- char buf[128];
-
- if ((!is_duration && ts == AV_NOPTS_VALUE) || (is_duration && ts == 0)) {
- writer_print_string(wctx, key, "N/A", PRINT_STRING_OPT);
- } else {
- double d = ts * av_q2d(*time_base);
- struct unit_value uv;
- uv.val.d = d;
- uv.unit = unit_second_str;
- value_string(buf, sizeof(buf), uv);
- writer_print_string(wctx, key, buf, 0);
- }
-}
-
-static void writer_print_ts(WriterContext *wctx, const char *key, int64_t ts, int is_duration)
-{
- if ((!is_duration && ts == AV_NOPTS_VALUE) || (is_duration && ts == 0)) {
- writer_print_string(wctx, key, "N/A", PRINT_STRING_OPT);
- } else {
- writer_print_integer(wctx, key, ts);
- }
-}
-
-static void writer_print_data(WriterContext *wctx, const char *name,
- const uint8_t *data, int size)
-{
- AVBPrint bp;
- int offset = 0, l, i;
-
- av_bprint_init(&bp, 0, AV_BPRINT_SIZE_UNLIMITED);
- av_bprintf(&bp, "\n");
- while (size) {
- av_bprintf(&bp, "%08x: ", offset);
- l = FFMIN(size, 16);
- for (i = 0; i < l; i++) {
- av_bprintf(&bp, "%02x", data[i]);
- if (i & 1)
- av_bprintf(&bp, " ");
- }
- av_bprint_chars(&bp, ' ', 41 - 2 * i - i / 2);
- for (i = 0; i < l; i++)
- av_bprint_chars(&bp, data[i] - 32U < 95 ? data[i] : '.', 1);
- av_bprintf(&bp, "\n");
- offset += l;
- data += l;
- size -= l;
- }
- writer_print_string(wctx, name, bp.str, 0);
- av_bprint_finalize(&bp, NULL);
-}
-
-static void writer_print_data_hash(WriterContext *wctx, const char *name,
- const uint8_t *data, int size)
-{
- char *p, buf[AV_HASH_MAX_SIZE * 2 + 64] = { 0 };
-
- if (!hash)
- return;
- av_hash_init(hash);
- av_hash_update(hash, data, size);
- snprintf(buf, sizeof(buf), "%s:", av_hash_get_name(hash));
- p = buf + strlen(buf);
- av_hash_final_hex(hash, p, buf + sizeof(buf) - p);
- writer_print_string(wctx, name, buf, 0);
-}
-
-static void writer_print_integers(WriterContext *wctx, const char *name,
- uint8_t *data, int size, const char *format,
- int columns, int bytes, int offset_add)
-{
- AVBPrint bp;
- int offset = 0, l, i;
-
- av_bprint_init(&bp, 0, AV_BPRINT_SIZE_UNLIMITED);
- av_bprintf(&bp, "\n");
- while (size) {
- av_bprintf(&bp, "%08x: ", offset);
- l = FFMIN(size, columns);
- for (i = 0; i < l; i++) {
- if (bytes == 1) av_bprintf(&bp, format, *data);
- else if (bytes == 2) av_bprintf(&bp, format, AV_RN16(data));
- else if (bytes == 4) av_bprintf(&bp, format, AV_RN32(data));
- data += bytes;
- size --;
- }
- av_bprintf(&bp, "\n");
- offset += offset_add;
- }
- writer_print_string(wctx, name, bp.str, 0);
- av_bprint_finalize(&bp, NULL);
-}
-
-#define writer_w8(wctx_, b_) (wctx_)->writer_w8(wctx_, b_)
-#define writer_put_str(wctx_, str_) (wctx_)->writer_put_str(wctx_, str_)
-#define writer_printf(wctx_, fmt_, ...) (wctx_)->writer_printf(wctx_, fmt_, __VA_ARGS__)
-
-#define MAX_REGISTERED_WRITERS_NB 64
-
-static const Writer *registered_writers[MAX_REGISTERED_WRITERS_NB + 1];
-
-static int writer_register(const Writer *writer)
-{
- static int next_registered_writer_idx = 0;
-
- if (next_registered_writer_idx == MAX_REGISTERED_WRITERS_NB)
- return AVERROR(ENOMEM);
-
- registered_writers[next_registered_writer_idx++] = writer;
- return 0;
-}
-
-static const Writer *writer_get_by_name(const char *name)
-{
- int i;
-
- for (i = 0; registered_writers[i]; i++)
- if (!strcmp(registered_writers[i]->name, name))
- return registered_writers[i];
-
- return NULL;
-}
-
-
-/* WRITERS */
-
-#define DEFINE_WRITER_CLASS(name) \
-static const char *name##_get_name(void *ctx) \
-{ \
- return #name ; \
-} \
-static const AVClass name##_class = { \
- .class_name = #name, \
- .item_name = name##_get_name, \
- .option = name##_options \
-}
-
-/* Default output */
-
-typedef struct DefaultContext {
- const AVClass *class;
- int nokey;
- int noprint_wrappers;
- int nested_section[SECTION_MAX_NB_LEVELS];
-} DefaultContext;
-
-#undef OFFSET
-#define OFFSET(x) offsetof(DefaultContext, x)
-
-static const AVOption default_options[] = {
- { "noprint_wrappers", "do not print headers and footers", OFFSET(noprint_wrappers), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
- { "nw", "do not print headers and footers", OFFSET(noprint_wrappers), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
- { "nokey", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
- { "nk", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
- {NULL},
-};
-
-DEFINE_WRITER_CLASS(default);
-
-/* lame uppercasing routine, assumes the string is lower case ASCII */
-static inline char *upcase_string(char *dst, size_t dst_size, const char *src)
-{
- int i;
- for (i = 0; src[i] && i < dst_size-1; i++)
- dst[i] = av_toupper(src[i]);
- dst[i] = 0;
- return dst;
-}
-
-static void default_print_section_header(WriterContext *wctx)
-{
- DefaultContext *def = wctx->priv;
- char buf[32];
- const struct section *section = wctx->section[wctx->level];
- const struct section *parent_section = wctx->level ?
- wctx->section[wctx->level-1] : NULL;
-
- av_bprint_clear(&wctx->section_pbuf[wctx->level]);
- if (parent_section &&
- !(parent_section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY))) {
- def->nested_section[wctx->level] = 1;
- av_bprintf(&wctx->section_pbuf[wctx->level], "%s%s:",
- wctx->section_pbuf[wctx->level-1].str,
- upcase_string(buf, sizeof(buf),
- av_x_if_null(section->element_name, section->name)));
- }
-
- if (def->noprint_wrappers || def->nested_section[wctx->level])
- return;
-
- if (!(section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY)))
- writer_printf(wctx, "[%s]\n", upcase_string(buf, sizeof(buf), section->name));
-}
-
-static void default_print_section_footer(WriterContext *wctx)
-{
- DefaultContext *def = wctx->priv;
- const struct section *section = wctx->section[wctx->level];
- char buf[32];
-
- if (def->noprint_wrappers || def->nested_section[wctx->level])
- return;
-
- if (!(section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY)))
- writer_printf(wctx, "[/%s]\n", upcase_string(buf, sizeof(buf), section->name));
-}
-
-static void default_print_str(WriterContext *wctx, const char *key, const char *value)
-{
- DefaultContext *def = wctx->priv;
-
- if (!def->nokey)
- writer_printf(wctx, "%s%s=", wctx->section_pbuf[wctx->level].str, key);
- writer_printf(wctx, "%s\n", value);
-}
-
-static void default_print_int(WriterContext *wctx, const char *key, long long int value)
-{
- DefaultContext *def = wctx->priv;
-
- if (!def->nokey)
- writer_printf(wctx, "%s%s=", wctx->section_pbuf[wctx->level].str, key);
- writer_printf(wctx, "%lld\n", value);
-}
-
-static const Writer default_writer = {
- .name = "default",
- .priv_size = sizeof(DefaultContext),
- .print_section_header = default_print_section_header,
- .print_section_footer = default_print_section_footer,
- .print_integer = default_print_int,
- .print_string = default_print_str,
- .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS,
- .priv_class = &default_class,
-};
-
-/* Compact output */
-
-/**
- * Apply C-language-like string escaping.
- */
-static const char *c_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
-{
- const char *p;
-
- for (p = src; *p; p++) {
- switch (*p) {
- case '\b': av_bprintf(dst, "%s", "\\b"); break;
- case '\f': av_bprintf(dst, "%s", "\\f"); break;
- case '\n': av_bprintf(dst, "%s", "\\n"); break;
- case '\r': av_bprintf(dst, "%s", "\\r"); break;
- case '\\': av_bprintf(dst, "%s", "\\\\"); break;
- default:
- if (*p == sep)
- av_bprint_chars(dst, '\\', 1);
- av_bprint_chars(dst, *p, 1);
- }
- }
- return dst->str;
-}
-
-/**
- * Quote fields containing special characters, check RFC4180.
- */
-static const char *csv_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
-{
- char meta_chars[] = { sep, '"', '\n', '\r', '\0' };
- int needs_quoting = !!src[strcspn(src, meta_chars)];
-
- if (needs_quoting)
- av_bprint_chars(dst, '"', 1);
-
- for (; *src; src++) {
- if (*src == '"')
- av_bprint_chars(dst, '"', 1);
- av_bprint_chars(dst, *src, 1);
- }
- if (needs_quoting)
- av_bprint_chars(dst, '"', 1);
- return dst->str;
-}
-
-static const char *none_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
-{
- return src;
-}
-
-typedef struct CompactContext {
- const AVClass *class;
- char *item_sep_str;
- char item_sep;
- int nokey;
- int print_section;
- char *escape_mode_str;
- const char * (*escape_str)(AVBPrint *dst, const char *src, const char sep, void *log_ctx);
- int nested_section[SECTION_MAX_NB_LEVELS];
- int has_nested_elems[SECTION_MAX_NB_LEVELS];
- int terminate_line[SECTION_MAX_NB_LEVELS];
-} CompactContext;
-
-#undef OFFSET
-#define OFFSET(x) offsetof(CompactContext, x)
-
-static const AVOption compact_options[]= {
- {"item_sep", "set item separator", OFFSET(item_sep_str), AV_OPT_TYPE_STRING, {.str="|"}, 0, 0 },
- {"s", "set item separator", OFFSET(item_sep_str), AV_OPT_TYPE_STRING, {.str="|"}, 0, 0 },
- {"nokey", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
- {"nk", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
- {"escape", "set escape mode", OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="c"}, 0, 0 },
- {"e", "set escape mode", OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="c"}, 0, 0 },
- {"print_section", "print section name", OFFSET(print_section), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
- {"p", "print section name", OFFSET(print_section), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
- {NULL},
-};
-
-DEFINE_WRITER_CLASS(compact);
-
-static av_cold int compact_init(WriterContext *wctx)
-{
- CompactContext *compact = wctx->priv;
-
- if (strlen(compact->item_sep_str) != 1) {
- av_log(wctx, AV_LOG_ERROR, "Item separator '%s' specified, but must contain a single character\n",
- compact->item_sep_str);
- return AVERROR(EINVAL);
- }
- compact->item_sep = compact->item_sep_str[0];
-
- if (!strcmp(compact->escape_mode_str, "none")) compact->escape_str = none_escape_str;
- else if (!strcmp(compact->escape_mode_str, "c" )) compact->escape_str = c_escape_str;
- else if (!strcmp(compact->escape_mode_str, "csv" )) compact->escape_str = csv_escape_str;
- else {
- av_log(wctx, AV_LOG_ERROR, "Unknown escape mode '%s'\n", compact->escape_mode_str);
- return AVERROR(EINVAL);
- }
-
- return 0;
-}
-
-static void compact_print_section_header(WriterContext *wctx)
-{
- CompactContext *compact = wctx->priv;
- const struct section *section = wctx->section[wctx->level];
- const struct section *parent_section = wctx->level ?
- wctx->section[wctx->level-1] : NULL;
- compact->terminate_line[wctx->level] = 1;
- compact->has_nested_elems[wctx->level] = 0;
-
- av_bprint_clear(&wctx->section_pbuf[wctx->level]);
- if (!(section->flags & SECTION_FLAG_IS_ARRAY) && parent_section &&
- !(parent_section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY))) {
- compact->nested_section[wctx->level] = 1;
- compact->has_nested_elems[wctx->level-1] = 1;
- av_bprintf(&wctx->section_pbuf[wctx->level], "%s%s:",
- wctx->section_pbuf[wctx->level-1].str,
- (char *)av_x_if_null(section->element_name, section->name));
- wctx->nb_item[wctx->level] = wctx->nb_item[wctx->level-1];
- } else {
- if (parent_section && compact->has_nested_elems[wctx->level-1] &&
- (section->flags & SECTION_FLAG_IS_ARRAY)) {
- compact->terminate_line[wctx->level-1] = 0;
- }
- if (parent_section && !(parent_section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY)) &&
- wctx->level && wctx->nb_item[wctx->level-1])
- writer_w8(wctx, compact->item_sep);
- if (compact->print_section &&
- !(section->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY)))
- writer_printf(wctx, "%s%c", section->name, compact->item_sep);
- }
-}
-
-static void compact_print_section_footer(WriterContext *wctx)
-{
- CompactContext *compact = wctx->priv;
-
- if (!compact->nested_section[wctx->level] &&
- compact->terminate_line[wctx->level] &&
- !(wctx->section[wctx->level]->flags & (SECTION_FLAG_IS_WRAPPER|SECTION_FLAG_IS_ARRAY)))
- writer_w8(wctx, '\n');
-}
-
-static void compact_print_str(WriterContext *wctx, const char *key, const char *value)
-{
- CompactContext *compact = wctx->priv;
- AVBPrint buf;
-
- if (wctx->nb_item[wctx->level]) writer_w8(wctx, compact->item_sep);
- if (!compact->nokey)
- writer_printf(wctx, "%s%s=", wctx->section_pbuf[wctx->level].str, key);
- av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
- writer_put_str(wctx, compact->escape_str(&buf, value, compact->item_sep, wctx));
- av_bprint_finalize(&buf, NULL);
-}
-
-static void compact_print_int(WriterContext *wctx, const char *key, long long int value)
-{
- CompactContext *compact = wctx->priv;
-
- if (wctx->nb_item[wctx->level]) writer_w8(wctx, compact->item_sep);
- if (!compact->nokey)
- writer_printf(wctx, "%s%s=", wctx->section_pbuf[wctx->level].str, key);
- writer_printf(wctx, "%lld", value);
-}
-
-static const Writer compact_writer = {
- .name = "compact",
- .priv_size = sizeof(CompactContext),
- .init = compact_init,
- .print_section_header = compact_print_section_header,
- .print_section_footer = compact_print_section_footer,
- .print_integer = compact_print_int,
- .print_string = compact_print_str,
- .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS,
- .priv_class = &compact_class,
-};
-
-/* CSV output */
-
-#undef OFFSET
-#define OFFSET(x) offsetof(CompactContext, x)
-
-static const AVOption csv_options[] = {
- {"item_sep", "set item separator", OFFSET(item_sep_str), AV_OPT_TYPE_STRING, {.str=","}, 0, 0 },
- {"s", "set item separator", OFFSET(item_sep_str), AV_OPT_TYPE_STRING, {.str=","}, 0, 0 },
- {"nokey", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
- {"nk", "force no key printing", OFFSET(nokey), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
- {"escape", "set escape mode", OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="csv"}, 0, 0 },
- {"e", "set escape mode", OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="csv"}, 0, 0 },
- {"print_section", "print section name", OFFSET(print_section), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
- {"p", "print section name", OFFSET(print_section), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
- {NULL},
-};
-
-DEFINE_WRITER_CLASS(csv);
-
-static const Writer csv_writer = {
- .name = "csv",
- .priv_size = sizeof(CompactContext),
- .init = compact_init,
- .print_section_header = compact_print_section_header,
- .print_section_footer = compact_print_section_footer,
- .print_integer = compact_print_int,
- .print_string = compact_print_str,
- .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS,
- .priv_class = &csv_class,
-};
-
-/* Flat output */
-
-typedef struct FlatContext {
- const AVClass *class;
- const char *sep_str;
- char sep;
- int hierarchical;
-} FlatContext;
-
-#undef OFFSET
-#define OFFSET(x) offsetof(FlatContext, x)
-
-static const AVOption flat_options[]= {
- {"sep_char", "set separator", OFFSET(sep_str), AV_OPT_TYPE_STRING, {.str="."}, 0, 0 },
- {"s", "set separator", OFFSET(sep_str), AV_OPT_TYPE_STRING, {.str="."}, 0, 0 },
- {"hierarchical", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
- {"h", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
- {NULL},
-};
-
-DEFINE_WRITER_CLASS(flat);
-
-static av_cold int flat_init(WriterContext *wctx)
-{
- FlatContext *flat = wctx->priv;
-
- if (strlen(flat->sep_str) != 1) {
- av_log(wctx, AV_LOG_ERROR, "Item separator '%s' specified, but must contain a single character\n",
- flat->sep_str);
- return AVERROR(EINVAL);
- }
- flat->sep = flat->sep_str[0];
-
- return 0;
-}
-
-static const char *flat_escape_key_str(AVBPrint *dst, const char *src, const char sep)
-{
- const char *p;
-
- for (p = src; *p; p++) {
- if (!((*p >= '0' && *p <= '9') ||
- (*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z')))
- av_bprint_chars(dst, '_', 1);
- else
- av_bprint_chars(dst, *p, 1);
- }
- return dst->str;
-}
-
-static const char *flat_escape_value_str(AVBPrint *dst, const char *src)
-{
- const char *p;
-
- for (p = src; *p; p++) {
- switch (*p) {
- case '\n': av_bprintf(dst, "%s", "\\n"); break;
- case '\r': av_bprintf(dst, "%s", "\\r"); break;
- case '\\': av_bprintf(dst, "%s", "\\\\"); break;
- case '"': av_bprintf(dst, "%s", "\\\""); break;
- case '`': av_bprintf(dst, "%s", "\\`"); break;
- case '$': av_bprintf(dst, "%s", "\\$"); break;
- default: av_bprint_chars(dst, *p, 1); break;
- }
- }
- return dst->str;
-}
-
-static void flat_print_section_header(WriterContext *wctx)
-{
- FlatContext *flat = wctx->priv;
- AVBPrint *buf = &wctx->section_pbuf[wctx->level];
- const struct section *section = wctx->section[wctx->level];
- const struct section *parent_section = wctx->level ?
- wctx->section[wctx->level-1] : NULL;
-
- /* build section header */
- av_bprint_clear(buf);
- if (!parent_section)
- return;
- av_bprintf(buf, "%s", wctx->section_pbuf[wctx->level-1].str);
-
- if (flat->hierarchical ||
- !(section->flags & (SECTION_FLAG_IS_ARRAY|SECTION_FLAG_IS_WRAPPER))) {
- av_bprintf(buf, "%s%s", wctx->section[wctx->level]->name, flat->sep_str);
-
- if (parent_section->flags & SECTION_FLAG_IS_ARRAY) {
- int n = parent_section->id == SECTION_ID_PACKETS_AND_FRAMES ?
- wctx->nb_section_packet_frame : wctx->nb_item[wctx->level-1];
- av_bprintf(buf, "%d%s", n, flat->sep_str);
- }
- }
-}
-
-static void flat_print_int(WriterContext *wctx, const char *key, long long int value)
-{
- writer_printf(wctx, "%s%s=%lld\n", wctx->section_pbuf[wctx->level].str, key, value);
-}
-
-static void flat_print_str(WriterContext *wctx, const char *key, const char *value)
-{
- FlatContext *flat = wctx->priv;
- AVBPrint buf;
-
- writer_put_str(wctx, wctx->section_pbuf[wctx->level].str);
- av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
- writer_printf(wctx, "%s=", flat_escape_key_str(&buf, key, flat->sep));
- av_bprint_clear(&buf);
- writer_printf(wctx, "\"%s\"\n", flat_escape_value_str(&buf, value));
- av_bprint_finalize(&buf, NULL);
-}
-
-static const Writer flat_writer = {
- .name = "flat",
- .priv_size = sizeof(FlatContext),
- .init = flat_init,
- .print_section_header = flat_print_section_header,
- .print_integer = flat_print_int,
- .print_string = flat_print_str,
- .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS|WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER,
- .priv_class = &flat_class,
-};
-
-/* INI format output */
-
-typedef struct INIContext {
- const AVClass *class;
- int hierarchical;
-} INIContext;
-
-#undef OFFSET
-#define OFFSET(x) offsetof(INIContext, x)
-
-static const AVOption ini_options[] = {
- {"hierarchical", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
- {"h", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1 },
- {NULL},
-};
-
-DEFINE_WRITER_CLASS(ini);
-
-static char *ini_escape_str(AVBPrint *dst, const char *src)
-{
- int i = 0;
- char c = 0;
-
- while (c = src[i++]) {
- switch (c) {
- case '\b': av_bprintf(dst, "%s", "\\b"); break;
- case '\f': av_bprintf(dst, "%s", "\\f"); break;
- case '\n': av_bprintf(dst, "%s", "\\n"); break;
- case '\r': av_bprintf(dst, "%s", "\\r"); break;
- case '\t': av_bprintf(dst, "%s", "\\t"); break;
- case '\\':
- case '#' :
- case '=' :
- case ':' : av_bprint_chars(dst, '\\', 1);
- default:
- if ((unsigned char)c < 32)
- av_bprintf(dst, "\\x00%02x", c & 0xff);
- else
- av_bprint_chars(dst, c, 1);
- break;
- }
- }
- return dst->str;
-}
-
-static void ini_print_section_header(WriterContext *wctx)
-{
- INIContext *ini = wctx->priv;
- AVBPrint *buf = &wctx->section_pbuf[wctx->level];
- const struct section *section = wctx->section[wctx->level];
- const struct section *parent_section = wctx->level ?
- wctx->section[wctx->level-1] : NULL;
-
- av_bprint_clear(buf);
- if (!parent_section) {
- writer_put_str(wctx, "# ffprobe output\n\n");
- return;
- }
-
- if (wctx->nb_item[wctx->level-1])
- writer_w8(wctx, '\n');
-
- av_bprintf(buf, "%s", wctx->section_pbuf[wctx->level-1].str);
- if (ini->hierarchical ||
- !(section->flags & (SECTION_FLAG_IS_ARRAY|SECTION_FLAG_IS_WRAPPER))) {
- av_bprintf(buf, "%s%s", buf->str[0] ? "." : "", wctx->section[wctx->level]->name);
-
- if (parent_section->flags & SECTION_FLAG_IS_ARRAY) {
- int n = parent_section->id == SECTION_ID_PACKETS_AND_FRAMES ?
- wctx->nb_section_packet_frame : wctx->nb_item[wctx->level-1];
- av_bprintf(buf, ".%d", n);
- }
- }
-
- if (!(section->flags & (SECTION_FLAG_IS_ARRAY|SECTION_FLAG_IS_WRAPPER)))
- writer_printf(wctx, "[%s]\n", buf->str);
-}
-
-static void ini_print_str(WriterContext *wctx, const char *key, const char *value)
-{
- AVBPrint buf;
-
- av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
- writer_printf(wctx, "%s=", ini_escape_str(&buf, key));
- av_bprint_clear(&buf);
- writer_printf(wctx, "%s\n", ini_escape_str(&buf, value));
- av_bprint_finalize(&buf, NULL);
-}
-
-static void ini_print_int(WriterContext *wctx, const char *key, long long int value)
-{
- writer_printf(wctx, "%s=%lld\n", key, value);
-}
-
-static const Writer ini_writer = {
- .name = "ini",
- .priv_size = sizeof(INIContext),
- .print_section_header = ini_print_section_header,
- .print_integer = ini_print_int,
- .print_string = ini_print_str,
- .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS|WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER,
- .priv_class = &ini_class,
-};
-
-/* JSON output */
-
-typedef struct JSONContext {
- const AVClass *class;
- int indent_level;
- int compact;
- const char *item_sep, *item_start_end;
-} JSONContext;
-
-#undef OFFSET
-#define OFFSET(x) offsetof(JSONContext, x)
-
-static const AVOption json_options[]= {
- { "compact", "enable compact output", OFFSET(compact), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
- { "c", "enable compact output", OFFSET(compact), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
- { NULL }
-};
-
-DEFINE_WRITER_CLASS(json);
-
-static av_cold int json_init(WriterContext *wctx)
-{
- JSONContext *json = wctx->priv;
-
- json->item_sep = json->compact ? ", " : ",\n";
- json->item_start_end = json->compact ? " " : "\n";
-
- return 0;
-}
-
-static const char *json_escape_str(AVBPrint *dst, const char *src, void *log_ctx)
-{
- static const char json_escape[] = {'"', '\\', '\b', '\f', '\n', '\r', '\t', 0};
- static const char json_subst[] = {'"', '\\', 'b', 'f', 'n', 'r', 't', 0};
- const char *p;
-
- for (p = src; *p; p++) {
- char *s = strchr(json_escape, *p);
- if (s) {
- av_bprint_chars(dst, '\\', 1);
- av_bprint_chars(dst, json_subst[s - json_escape], 1);
- } else if ((unsigned char)*p < 32) {
- av_bprintf(dst, "\\u00%02x", *p & 0xff);
- } else {
- av_bprint_chars(dst, *p, 1);
- }
- }
- return dst->str;
-}
-
-#define JSON_INDENT() writer_printf(wctx, "%*c", json->indent_level * 4, ' ')
-
-static void json_print_section_header(WriterContext *wctx)
-{
- JSONContext *json = wctx->priv;
- AVBPrint buf;
- const struct section *section = wctx->section[wctx->level];
- const struct section *parent_section = wctx->level ?
- wctx->section[wctx->level-1] : NULL;
-
- if (wctx->level && wctx->nb_item[wctx->level-1])
- writer_put_str(wctx, ",\n");
-
- if (section->flags & SECTION_FLAG_IS_WRAPPER) {
- writer_put_str(wctx, "{\n");
- json->indent_level++;
- } else {
- av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
- json_escape_str(&buf, section->name, wctx);
- JSON_INDENT();
-
- json->indent_level++;
- if (section->flags & SECTION_FLAG_IS_ARRAY) {
- writer_printf(wctx, "\"%s\": [\n", buf.str);
- } else if (parent_section && !(parent_section->flags & SECTION_FLAG_IS_ARRAY)) {
- writer_printf(wctx, "\"%s\": {%s", buf.str, json->item_start_end);
- } else {
- writer_printf(wctx, "{%s", json->item_start_end);
-
- /* this is required so the parser can distinguish between packets and frames */
- if (parent_section && parent_section->id == SECTION_ID_PACKETS_AND_FRAMES) {
- if (!json->compact)
- JSON_INDENT();
- writer_printf(wctx, "\"type\": \"%s\"", section->name);
- wctx->nb_item[wctx->level]++;
- }
- }
- av_bprint_finalize(&buf, NULL);
- }
-}
-
-static void json_print_section_footer(WriterContext *wctx)
-{
- JSONContext *json = wctx->priv;
- const struct section *section = wctx->section[wctx->level];
-
- if (wctx->level == 0) {
- json->indent_level--;
- writer_put_str(wctx, "\n}\n");
- } else if (section->flags & SECTION_FLAG_IS_ARRAY) {
- writer_w8(wctx, '\n');
- json->indent_level--;
- JSON_INDENT();
- writer_w8(wctx, ']');
- } else {
- writer_put_str(wctx, json->item_start_end);
- json->indent_level--;
- if (!json->compact)
- JSON_INDENT();
- writer_w8(wctx, '}');
- }
-}
-
-static inline void json_print_item_str(WriterContext *wctx,
- const char *key, const char *value)
-{
- AVBPrint buf;
-
- av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
- writer_printf(wctx, "\"%s\":", json_escape_str(&buf, key, wctx));
- av_bprint_clear(&buf);
- writer_printf(wctx, " \"%s\"", json_escape_str(&buf, value, wctx));
- av_bprint_finalize(&buf, NULL);
-}
-
-static void json_print_str(WriterContext *wctx, const char *key, const char *value)
-{
- JSONContext *json = wctx->priv;
- const struct section *parent_section = wctx->level ?
- wctx->section[wctx->level-1] : NULL;
-
- if (wctx->nb_item[wctx->level] || (parent_section && parent_section->id == SECTION_ID_PACKETS_AND_FRAMES))
- writer_put_str(wctx, json->item_sep);
- if (!json->compact)
- JSON_INDENT();
- json_print_item_str(wctx, key, value);
-}
-
-static void json_print_int(WriterContext *wctx, const char *key, long long int value)
-{
- JSONContext *json = wctx->priv;
- const struct section *parent_section = wctx->level ?
- wctx->section[wctx->level-1] : NULL;
- AVBPrint buf;
-
- if (wctx->nb_item[wctx->level] || (parent_section && parent_section->id == SECTION_ID_PACKETS_AND_FRAMES))
- writer_put_str(wctx, json->item_sep);
- if (!json->compact)
- JSON_INDENT();
-
- av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
- writer_printf(wctx, "\"%s\": %lld", json_escape_str(&buf, key, wctx), value);
- av_bprint_finalize(&buf, NULL);
-}
-
-static const Writer json_writer = {
- .name = "json",
- .priv_size = sizeof(JSONContext),
- .init = json_init,
- .print_section_header = json_print_section_header,
- .print_section_footer = json_print_section_footer,
- .print_integer = json_print_int,
- .print_string = json_print_str,
- .flags = WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER,
- .priv_class = &json_class,
-};
-
-/* XML output */
-
-typedef struct XMLContext {
- const AVClass *class;
- int within_tag;
- int indent_level;
- int fully_qualified;
- int xsd_strict;
-} XMLContext;
-
-#undef OFFSET
-#define OFFSET(x) offsetof(XMLContext, x)
-
-static const AVOption xml_options[] = {
- {"fully_qualified", "specify if the output should be fully qualified", OFFSET(fully_qualified), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
- {"q", "specify if the output should be fully qualified", OFFSET(fully_qualified), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
- {"xsd_strict", "ensure that the output is XSD compliant", OFFSET(xsd_strict), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
- {"x", "ensure that the output is XSD compliant", OFFSET(xsd_strict), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 },
- {NULL},
-};
-
-DEFINE_WRITER_CLASS(xml);
-
-static av_cold int xml_init(WriterContext *wctx)
-{
- XMLContext *xml = wctx->priv;
-
- if (xml->xsd_strict) {
- xml->fully_qualified = 1;
-#define CHECK_COMPLIANCE(opt, opt_name) \
- if (opt) { \
- av_log(wctx, AV_LOG_ERROR, \
- "XSD-compliant output selected but option '%s' was selected, XML output may be non-compliant.\n" \
- "You need to disable such option with '-no%s'\n", opt_name, opt_name); \
- return AVERROR(EINVAL); \
- }
- CHECK_COMPLIANCE(show_private_data, "private");
- CHECK_COMPLIANCE(show_value_unit, "unit");
- CHECK_COMPLIANCE(use_value_prefix, "prefix");
- }
-
- return 0;
-}
-
-#define XML_INDENT() writer_printf(wctx, "%*c", xml->indent_level * 4, ' ')
-
-static void xml_print_section_header(WriterContext *wctx)
-{
- XMLContext *xml = wctx->priv;
- const struct section *section = wctx->section[wctx->level];
- const struct section *parent_section = wctx->level ?
- wctx->section[wctx->level-1] : NULL;
-
- if (wctx->level == 0) {
- const char *qual = " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" "
- "xmlns:ffprobe=\"http://www.ffmpeg.org/schema/ffprobe\" "
- "xsi:schemaLocation=\"http://www.ffmpeg.org/schema/ffprobe ffprobe.xsd\"";
-
- writer_put_str(wctx, "\n");
- writer_printf(wctx, "<%sffprobe%s>\n",
- xml->fully_qualified ? "ffprobe:" : "",
- xml->fully_qualified ? qual : "");
- return;
- }
-
- if (xml->within_tag) {
- xml->within_tag = 0;
- writer_put_str(wctx, ">\n");
- }
- if (section->flags & SECTION_FLAG_HAS_VARIABLE_FIELDS) {
- xml->indent_level++;
- } else {
- if (parent_section && (parent_section->flags & SECTION_FLAG_IS_WRAPPER) &&
- wctx->level && wctx->nb_item[wctx->level-1])
- writer_w8(wctx, '\n');
- xml->indent_level++;
-
- if (section->flags & SECTION_FLAG_IS_ARRAY) {
- XML_INDENT(); writer_printf(wctx, "<%s>\n", section->name);
- } else {
- XML_INDENT(); writer_printf(wctx, "<%s ", section->name);
- xml->within_tag = 1;
- }
- }
-}
-
-static void xml_print_section_footer(WriterContext *wctx)
-{
- XMLContext *xml = wctx->priv;
- const struct section *section = wctx->section[wctx->level];
-
- if (wctx->level == 0) {
- writer_printf(wctx, "\n", xml->fully_qualified ? "ffprobe:" : "");
- } else if (xml->within_tag) {
- xml->within_tag = 0;
- writer_put_str(wctx, "/>\n");
- xml->indent_level--;
- } else if (section->flags & SECTION_FLAG_HAS_VARIABLE_FIELDS) {
- xml->indent_level--;
- } else {
- XML_INDENT(); writer_printf(wctx, "\n", section->name);
- xml->indent_level--;
- }
-}
-
-static void xml_print_str(WriterContext *wctx, const char *key, const char *value)
-{
- AVBPrint buf;
- XMLContext *xml = wctx->priv;
- const struct section *section = wctx->section[wctx->level];
-
- av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
-
- if (section->flags & SECTION_FLAG_HAS_VARIABLE_FIELDS) {
- XML_INDENT();
- av_bprint_escape(&buf, key, NULL,
- AV_ESCAPE_MODE_XML, AV_ESCAPE_FLAG_XML_DOUBLE_QUOTES);
- writer_printf(wctx, "<%s key=\"%s\"",
- section->element_name, buf.str);
- av_bprint_clear(&buf);
-
- av_bprint_escape(&buf, value, NULL,
- AV_ESCAPE_MODE_XML, AV_ESCAPE_FLAG_XML_DOUBLE_QUOTES);
- writer_printf(wctx, " value=\"%s\"/>\n", buf.str);
- } else {
- if (wctx->nb_item[wctx->level])
- writer_w8(wctx, ' ');
-
- av_bprint_escape(&buf, value, NULL,
- AV_ESCAPE_MODE_XML, AV_ESCAPE_FLAG_XML_DOUBLE_QUOTES);
- writer_printf(wctx, "%s=\"%s\"", key, buf.str);
- }
-
- av_bprint_finalize(&buf, NULL);
-}
-
-static void xml_print_int(WriterContext *wctx, const char *key, long long int value)
-{
- if (wctx->nb_item[wctx->level])
- writer_w8(wctx, ' ');
- writer_printf(wctx, "%s=\"%lld\"", key, value);
-}
-
-static Writer xml_writer = {
- .name = "xml",
- .priv_size = sizeof(XMLContext),
- .init = xml_init,
- .print_section_header = xml_print_section_header,
- .print_section_footer = xml_print_section_footer,
- .print_integer = xml_print_int,
- .print_string = xml_print_str,
- .flags = WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER,
- .priv_class = &xml_class,
-};
-
-static void writer_register_all(void)
-{
- static int initialized;
-
- if (initialized)
- return;
- initialized = 1;
-
- writer_register(&default_writer);
- writer_register(&compact_writer);
- writer_register(&csv_writer);
- writer_register(&flat_writer);
- writer_register(&ini_writer);
- writer_register(&json_writer);
- writer_register(&xml_writer);
-}
-
-#define print_fmt(k, f, ...) do { \
- av_bprint_clear(&pbuf); \
- av_bprintf(&pbuf, f, __VA_ARGS__); \
- writer_print_string(w, k, pbuf.str, 0); \
-} while (0)
-
-#define print_list_fmt(k, f, n, m, ...) do { \
- av_bprint_clear(&pbuf); \
- for (int idx = 0; idx < n; idx++) { \
- for (int idx2 = 0; idx2 < m; idx2++) { \
- if (idx > 0 || idx2 > 0) \
- av_bprint_chars(&pbuf, ' ', 1); \
- av_bprintf(&pbuf, f, __VA_ARGS__); \
- } \
- } \
- writer_print_string(w, k, pbuf.str, 0); \
-} while (0)
-
-#define print_int(k, v) writer_print_integer(w, k, v)
-#define print_q(k, v, s) writer_print_rational(w, k, v, s)
-#define print_str(k, v) writer_print_string(w, k, v, 0)
-#define print_str_opt(k, v) writer_print_string(w, k, v, PRINT_STRING_OPT)
-#define print_str_validate(k, v) writer_print_string(w, k, v, PRINT_STRING_VALIDATE)
-#define print_time(k, v, tb) writer_print_time(w, k, v, tb, 0)
-#define print_ts(k, v) writer_print_ts(w, k, v, 0)
-#define print_duration_time(k, v, tb) writer_print_time(w, k, v, tb, 1)
-#define print_duration_ts(k, v) writer_print_ts(w, k, v, 1)
-#define print_val(k, v, u) do { \
- struct unit_value uv; \
- uv.val.i = v; \
- uv.unit = u; \
- writer_print_string(w, k, value_string(val_str, sizeof(val_str), uv), 0); \
-} while (0)
-
-#define print_section_header(s) writer_print_section_header(w, s)
-#define print_section_footer(s) writer_print_section_footer(w, s)
-
-#define REALLOCZ_ARRAY_STREAM(ptr, cur_n, new_n) \
-{ \
- ret = av_reallocp_array(&(ptr), (new_n), sizeof(*(ptr))); \
- if (ret < 0) \
- goto end; \
- memset( (ptr) + (cur_n), 0, ((new_n) - (cur_n)) * sizeof(*(ptr)) ); \
-}
-
-static inline int show_tags(WriterContext *w, AVDictionary *tags, int section_id)
-{
- const AVDictionaryEntry *tag = NULL;
- int ret = 0;
-
- if (!tags)
- return 0;
- writer_print_section_header(w, section_id);
-
- while ((tag = av_dict_iterate(tags, tag))) {
- if ((ret = print_str_validate(tag->key, tag->value)) < 0)
- break;
- }
- writer_print_section_footer(w);
-
- return ret;
-}
-
-static void print_dovi_metadata(WriterContext *w, const AVDOVIMetadata *dovi)
-{
- if (!dovi)
- return;
-
- {
- const AVDOVIRpuDataHeader *hdr = av_dovi_get_header(dovi);
- const AVDOVIDataMapping *mapping = av_dovi_get_mapping(dovi);
- const AVDOVIColorMetadata *color = av_dovi_get_color(dovi);
- AVBPrint pbuf;
-
- av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
-
- // header
- print_int("rpu_type", hdr->rpu_type);
- print_int("rpu_format", hdr->rpu_format);
- print_int("vdr_rpu_profile", hdr->vdr_rpu_profile);
- print_int("vdr_rpu_level", hdr->vdr_rpu_level);
- print_int("chroma_resampling_explicit_filter_flag",
- hdr->chroma_resampling_explicit_filter_flag);
- print_int("coef_data_type", hdr->coef_data_type);
- print_int("coef_log2_denom", hdr->coef_log2_denom);
- print_int("vdr_rpu_normalized_idc", hdr->vdr_rpu_normalized_idc);
- print_int("bl_video_full_range_flag", hdr->bl_video_full_range_flag);
- print_int("bl_bit_depth", hdr->bl_bit_depth);
- print_int("el_bit_depth", hdr->el_bit_depth);
- print_int("vdr_bit_depth", hdr->vdr_bit_depth);
- print_int("spatial_resampling_filter_flag",
- hdr->spatial_resampling_filter_flag);
- print_int("el_spatial_resampling_filter_flag",
- hdr->el_spatial_resampling_filter_flag);
- print_int("disable_residual_flag", hdr->disable_residual_flag);
-
- // data mapping values
- print_int("vdr_rpu_id", mapping->vdr_rpu_id);
- print_int("mapping_color_space", mapping->mapping_color_space);
- print_int("mapping_chroma_format_idc",
- mapping->mapping_chroma_format_idc);
-
- print_int("nlq_method_idc", mapping->nlq_method_idc);
- switch (mapping->nlq_method_idc) {
- case AV_DOVI_NLQ_NONE:
- print_str("nlq_method_idc_name", "none");
- break;
- case AV_DOVI_NLQ_LINEAR_DZ:
- print_str("nlq_method_idc_name", "linear_dz");
- break;
- default:
- print_str("nlq_method_idc_name", "unknown");
- break;
- }
-
- print_int("num_x_partitions", mapping->num_x_partitions);
- print_int("num_y_partitions", mapping->num_y_partitions);
-
- writer_print_section_header(w, SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST);
-
- for (int c = 0; c < 3; c++) {
- const AVDOVIReshapingCurve *curve = &mapping->curves[c];
- writer_print_section_header(w, SECTION_ID_FRAME_SIDE_DATA_COMPONENT);
-
- print_list_fmt("pivots", "%"PRIu16, curve->num_pivots, 1, curve->pivots[idx]);
-
- writer_print_section_header(w, SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST);
- for (int i = 0; i < curve->num_pivots - 1; i++) {
-
- writer_print_section_header(w, SECTION_ID_FRAME_SIDE_DATA_PIECE);
- print_int("mapping_idc", curve->mapping_idc[i]);
- switch (curve->mapping_idc[i]) {
- case AV_DOVI_MAPPING_POLYNOMIAL:
- print_str("mapping_idc_name", "polynomial");
- print_int("poly_order", curve->poly_order[i]);
- print_list_fmt("poly_coef", "%"PRIi64,
- curve->poly_order[i] + 1, 1,
- curve->poly_coef[i][idx]);
- break;
- case AV_DOVI_MAPPING_MMR:
- print_str("mapping_idc_name", "mmr");
- print_int("mmr_order", curve->mmr_order[i]);
- print_int("mmr_constant", curve->mmr_constant[i]);
- print_list_fmt("mmr_coef", "%"PRIi64,
- curve->mmr_order[i], 7,
- curve->mmr_coef[i][idx][idx2]);
- break;
- default:
- print_str("mapping_idc_name", "unknown");
- break;
- }
-
- // SECTION_ID_FRAME_SIDE_DATA_PIECE
- writer_print_section_footer(w);
- }
-
- // SECTION_ID_FRAME_SIDE_DATA_PIECE_LIST
- writer_print_section_footer(w);
-
- if (mapping->nlq_method_idc != AV_DOVI_NLQ_NONE) {
- const AVDOVINLQParams *nlq = &mapping->nlq[c];
- print_int("nlq_offset", nlq->nlq_offset);
- print_int("vdr_in_max", nlq->vdr_in_max);
-
- switch (mapping->nlq_method_idc) {
- case AV_DOVI_NLQ_LINEAR_DZ:
- print_int("linear_deadzone_slope", nlq->linear_deadzone_slope);
- print_int("linear_deadzone_threshold", nlq->linear_deadzone_threshold);
- break;
- }
- }
-
- // SECTION_ID_FRAME_SIDE_DATA_COMPONENT
- writer_print_section_footer(w);
- }
-
- // SECTION_ID_FRAME_SIDE_DATA_COMPONENT_LIST
- writer_print_section_footer(w);
-
- // color metadata
- print_int("dm_metadata_id", color->dm_metadata_id);
- print_int("scene_refresh_flag", color->scene_refresh_flag);
- print_list_fmt("ycc_to_rgb_matrix", "%d/%d",
- FF_ARRAY_ELEMS(color->ycc_to_rgb_matrix), 1,
- color->ycc_to_rgb_matrix[idx].num,
- color->ycc_to_rgb_matrix[idx].den);
- print_list_fmt("ycc_to_rgb_offset", "%d/%d",
- FF_ARRAY_ELEMS(color->ycc_to_rgb_offset), 1,
- color->ycc_to_rgb_offset[idx].num,
- color->ycc_to_rgb_offset[idx].den);
- print_list_fmt("rgb_to_lms_matrix", "%d/%d",
- FF_ARRAY_ELEMS(color->rgb_to_lms_matrix), 1,
- color->rgb_to_lms_matrix[idx].num,
- color->rgb_to_lms_matrix[idx].den);
- print_int("signal_eotf", color->signal_eotf);
- print_int("signal_eotf_param0", color->signal_eotf_param0);
- print_int("signal_eotf_param1", color->signal_eotf_param1);
- print_int("signal_eotf_param2", color->signal_eotf_param2);
- print_int("signal_bit_depth", color->signal_bit_depth);
- print_int("signal_color_space", color->signal_color_space);
- print_int("signal_chroma_format", color->signal_chroma_format);
- print_int("signal_full_range_flag", color->signal_full_range_flag);
- print_int("source_min_pq", color->source_min_pq);
- print_int("source_max_pq", color->source_max_pq);
- print_int("source_diagonal", color->source_diagonal);
-
- av_bprint_finalize(&pbuf, NULL);
- }
-}
-
-static void print_dynamic_hdr10_plus(WriterContext *w, const AVDynamicHDRPlus *metadata)
-{
- if (!metadata)
- return;
- print_int("application version", metadata->application_version);
- print_int("num_windows", metadata->num_windows);
- for (int n = 1; n < metadata->num_windows; n++) {
- const AVHDRPlusColorTransformParams *params = &metadata->params[n];
- print_q("window_upper_left_corner_x",
- params->window_upper_left_corner_x,'/');
- print_q("window_upper_left_corner_y",
- params->window_upper_left_corner_y,'/');
- print_q("window_lower_right_corner_x",
- params->window_lower_right_corner_x,'/');
- print_q("window_lower_right_corner_y",
- params->window_lower_right_corner_y,'/');
- print_q("window_upper_left_corner_x",
- params->window_upper_left_corner_x,'/');
- print_q("window_upper_left_corner_y",
- params->window_upper_left_corner_y,'/');
- print_int("center_of_ellipse_x",
- params->center_of_ellipse_x ) ;
- print_int("center_of_ellipse_y",
- params->center_of_ellipse_y );
- print_int("rotation_angle",
- params->rotation_angle);
- print_int("semimajor_axis_internal_ellipse",
- params->semimajor_axis_internal_ellipse);
- print_int("semimajor_axis_external_ellipse",
- params->semimajor_axis_external_ellipse);
- print_int("semiminor_axis_external_ellipse",
- params->semiminor_axis_external_ellipse);
- print_int("overlap_process_option",
- params->overlap_process_option);
- }
- print_q("targeted_system_display_maximum_luminance",
- metadata->targeted_system_display_maximum_luminance,'/');
- if (metadata->targeted_system_display_actual_peak_luminance_flag) {
- print_int("num_rows_targeted_system_display_actual_peak_luminance",
- metadata->num_rows_targeted_system_display_actual_peak_luminance);
- print_int("num_cols_targeted_system_display_actual_peak_luminance",
- metadata->num_cols_targeted_system_display_actual_peak_luminance);
- for (int i = 0; i < metadata->num_rows_targeted_system_display_actual_peak_luminance; i++) {
- for (int j = 0; j < metadata->num_cols_targeted_system_display_actual_peak_luminance; j++) {
- print_q("targeted_system_display_actual_peak_luminance",
- metadata->targeted_system_display_actual_peak_luminance[i][j],'/');
- }
- }
- }
- for (int n = 0; n < metadata->num_windows; n++) {
- const AVHDRPlusColorTransformParams *params = &metadata->params[n];
- for (int i = 0; i < 3; i++) {
- print_q("maxscl",params->maxscl[i],'/');
- }
- print_q("average_maxrgb",
- params->average_maxrgb,'/');
- print_int("num_distribution_maxrgb_percentiles",
- params->num_distribution_maxrgb_percentiles);
- for (int i = 0; i < params->num_distribution_maxrgb_percentiles; i++) {
- print_int("distribution_maxrgb_percentage",
- params->distribution_maxrgb[i].percentage);
- print_q("distribution_maxrgb_percentile",
- params->distribution_maxrgb[i].percentile,'/');
- }
- print_q("fraction_bright_pixels",
- params->fraction_bright_pixels,'/');
- }
- if (metadata->mastering_display_actual_peak_luminance_flag) {
- print_int("num_rows_mastering_display_actual_peak_luminance",
- metadata->num_rows_mastering_display_actual_peak_luminance);
- print_int("num_cols_mastering_display_actual_peak_luminance",
- metadata->num_cols_mastering_display_actual_peak_luminance);
- for (int i = 0; i < metadata->num_rows_mastering_display_actual_peak_luminance; i++) {
- for (int j = 0; j < metadata->num_cols_mastering_display_actual_peak_luminance; j++) {
- print_q("mastering_display_actual_peak_luminance",
- metadata->mastering_display_actual_peak_luminance[i][j],'/');
- }
- }
- }
-
- for (int n = 0; n < metadata->num_windows; n++) {
- const AVHDRPlusColorTransformParams *params = &metadata->params[n];
- if (params->tone_mapping_flag) {
- print_q("knee_point_x", params->knee_point_x,'/');
- print_q("knee_point_y", params->knee_point_y,'/');
- print_int("num_bezier_curve_anchors",
- params->num_bezier_curve_anchors );
- for (int i = 0; i < params->num_bezier_curve_anchors; i++) {
- print_q("bezier_curve_anchors",
- params->bezier_curve_anchors[i],'/');
- }
- }
- if (params->color_saturation_mapping_flag) {
- print_q("color_saturation_weight",
- params->color_saturation_weight,'/');
- }
- }
-}
-
-static void print_dynamic_hdr_vivid(WriterContext *w, const AVDynamicHDRVivid *metadata)
-{
- if (!metadata)
- return;
- print_int("system_start_code", metadata->system_start_code);
- print_int("num_windows", metadata->num_windows);
-
- for (int n = 0; n < metadata->num_windows; n++) {
- const AVHDRVividColorTransformParams *params = &metadata->params[n];
-
- print_q("minimum_maxrgb", params->minimum_maxrgb, '/');
- print_q("average_maxrgb", params->average_maxrgb, '/');
- print_q("variance_maxrgb", params->variance_maxrgb, '/');
- print_q("maximum_maxrgb", params->maximum_maxrgb, '/');
- }
-
- for (int n = 0; n < metadata->num_windows; n++) {
- const AVHDRVividColorTransformParams *params = &metadata->params[n];
-
- print_int("tone_mapping_mode_flag", params->tone_mapping_mode_flag);
- if (params->tone_mapping_mode_flag) {
- print_int("tone_mapping_param_num", params->tone_mapping_param_num);
- for (int i = 0; i < params->tone_mapping_param_num; i++) {
- const AVHDRVividColorToneMappingParams *tm_params = ¶ms->tm_params[i];
-
- print_q("targeted_system_display_maximum_luminance",
- tm_params->targeted_system_display_maximum_luminance, '/');
- print_int("base_enable_flag", tm_params->base_enable_flag);
- if (tm_params->base_enable_flag) {
- print_q("base_param_m_p", tm_params->base_param_m_p, '/');
- print_q("base_param_m_m", tm_params->base_param_m_m, '/');
- print_q("base_param_m_a", tm_params->base_param_m_a, '/');
- print_q("base_param_m_b", tm_params->base_param_m_b, '/');
- print_q("base_param_m_n", tm_params->base_param_m_n, '/');
-
- print_int("base_param_k1", tm_params->base_param_k1);
- print_int("base_param_k2", tm_params->base_param_k2);
- print_int("base_param_k3", tm_params->base_param_k3);
- print_int("base_param_Delta_enable_mode",
- tm_params->base_param_Delta_enable_mode);
- print_q("base_param_Delta", tm_params->base_param_Delta, '/');
- }
- print_int("3Spline_enable_flag", tm_params->three_Spline_enable_flag);
- if (tm_params->three_Spline_enable_flag) {
- print_int("3Spline_num", tm_params->three_Spline_num);
-
- for (int j = 0; j < tm_params->three_Spline_num; j++) {
- const AVHDRVivid3SplineParams *three_spline = &tm_params->three_spline[j];
- print_int("3Spline_TH_mode", three_spline->th_mode);
- if (three_spline->th_mode == 0 || three_spline->th_mode == 2)
- print_q("3Spline_TH_enable_MB", three_spline->th_enable_mb, '/');
- print_q("3Spline_TH_enable", three_spline->th_enable, '/');
- print_q("3Spline_TH_Delta1", three_spline->th_delta1, '/');
- print_q("3Spline_TH_Delta2", three_spline->th_delta2, '/');
- print_q("3Spline_enable_Strength", three_spline->enable_strength, '/');
- }
- }
- }
- }
-
- print_int("color_saturation_mapping_flag", params->color_saturation_mapping_flag);
- if (params->color_saturation_mapping_flag) {
- print_int("color_saturation_num", params->color_saturation_num);
- for (int i = 0; i < params->color_saturation_num; i++) {
- print_q("color_saturation_gain", params->color_saturation_gain[i], '/');
- }
- }
- }
-}
-
-static void print_ambient_viewing_environment(WriterContext *w,
- const AVAmbientViewingEnvironment *env)
-{
- if (!env)
- return;
-
- print_q("ambient_illuminance", env->ambient_illuminance, '/');
- print_q("ambient_light_x", env->ambient_light_x, '/');
- print_q("ambient_light_y", env->ambient_light_y, '/');
-}
-
-static void print_pkt_side_data(WriterContext *w,
- AVCodecParameters *par,
- const AVPacketSideData *side_data,
- int nb_side_data,
- SectionID id_data_list,
- SectionID id_data)
-{
- int i;
-
- writer_print_section_header(w, id_data_list);
- for (i = 0; i < nb_side_data; i++) {
- const AVPacketSideData *sd = &side_data[i];
- const char *name = av_packet_side_data_name(sd->type);
-
- writer_print_section_header(w, id_data);
- print_str("side_data_type", name ? name : "unknown");
- if (sd->type == AV_PKT_DATA_DISPLAYMATRIX && sd->size >= 9*4) {
- double rotation = av_display_rotation_get((int32_t *)sd->data);
- if (isnan(rotation))
- rotation = 0;
- writer_print_integers(w, "displaymatrix", sd->data, 9, " %11d", 3, 4, 1);
- print_int("rotation", rotation);
- } else if (sd->type == AV_PKT_DATA_STEREO3D) {
- const AVStereo3D *stereo = (AVStereo3D *)sd->data;
- print_str("type", av_stereo3d_type_name(stereo->type));
- print_int("inverted", !!(stereo->flags & AV_STEREO3D_FLAG_INVERT));
- } else if (sd->type == AV_PKT_DATA_SPHERICAL) {
- const AVSphericalMapping *spherical = (AVSphericalMapping *)sd->data;
- print_str("projection", av_spherical_projection_name(spherical->projection));
- if (spherical->projection == AV_SPHERICAL_CUBEMAP) {
- print_int("padding", spherical->padding);
- } else if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR_TILE) {
- size_t l, t, r, b;
- av_spherical_tile_bounds(spherical, par->width, par->height,
- &l, &t, &r, &b);
- print_int("bound_left", l);
- print_int("bound_top", t);
- print_int("bound_right", r);
- print_int("bound_bottom", b);
- }
-
- print_int("yaw", (double) spherical->yaw / (1 << 16));
- print_int("pitch", (double) spherical->pitch / (1 << 16));
- print_int("roll", (double) spherical->roll / (1 << 16));
- } else if (sd->type == AV_PKT_DATA_SKIP_SAMPLES && sd->size == 10) {
- print_int("skip_samples", AV_RL32(sd->data));
- print_int("discard_padding", AV_RL32(sd->data + 4));
- print_int("skip_reason", AV_RL8(sd->data + 8));
- print_int("discard_reason", AV_RL8(sd->data + 9));
- } else if (sd->type == AV_PKT_DATA_MASTERING_DISPLAY_METADATA) {
- AVMasteringDisplayMetadata *metadata = (AVMasteringDisplayMetadata *)sd->data;
-
- if (metadata->has_primaries) {
- print_q("red_x", metadata->display_primaries[0][0], '/');
- print_q("red_y", metadata->display_primaries[0][1], '/');
- print_q("green_x", metadata->display_primaries[1][0], '/');
- print_q("green_y", metadata->display_primaries[1][1], '/');
- print_q("blue_x", metadata->display_primaries[2][0], '/');
- print_q("blue_y", metadata->display_primaries[2][1], '/');
-
- print_q("white_point_x", metadata->white_point[0], '/');
- print_q("white_point_y", metadata->white_point[1], '/');
- }
-
- if (metadata->has_luminance) {
- print_q("min_luminance", metadata->min_luminance, '/');
- print_q("max_luminance", metadata->max_luminance, '/');
- }
- } else if (sd->type == AV_PKT_DATA_CONTENT_LIGHT_LEVEL) {
- AVContentLightMetadata *metadata = (AVContentLightMetadata *)sd->data;
- print_int("max_content", metadata->MaxCLL);
- print_int("max_average", metadata->MaxFALL);
- } else if (sd->type == AV_PKT_DATA_DYNAMIC_HDR10_PLUS) {
- AVDynamicHDRPlus *metadata = (AVDynamicHDRPlus *)sd->data;
- print_dynamic_hdr10_plus(w, metadata);
- } else if (sd->type == AV_PKT_DATA_DOVI_CONF) {
- AVDOVIDecoderConfigurationRecord *dovi = (AVDOVIDecoderConfigurationRecord *)sd->data;
- print_int("dv_version_major", dovi->dv_version_major);
- print_int("dv_version_minor", dovi->dv_version_minor);
- print_int("dv_profile", dovi->dv_profile);
- print_int("dv_level", dovi->dv_level);
- print_int("rpu_present_flag", dovi->rpu_present_flag);
- print_int("el_present_flag", dovi->el_present_flag);
- print_int("bl_present_flag", dovi->bl_present_flag);
- print_int("dv_bl_signal_compatibility_id", dovi->dv_bl_signal_compatibility_id);
- } else if (sd->type == AV_PKT_DATA_AUDIO_SERVICE_TYPE) {
- enum AVAudioServiceType *t = (enum AVAudioServiceType *)sd->data;
- print_int("service_type", *t);
- } else if (sd->type == AV_PKT_DATA_MPEGTS_STREAM_ID) {
- print_int("id", *sd->data);
- } else if (sd->type == AV_PKT_DATA_CPB_PROPERTIES) {
- const AVCPBProperties *prop = (AVCPBProperties *)sd->data;
- print_int("max_bitrate", prop->max_bitrate);
- print_int("min_bitrate", prop->min_bitrate);
- print_int("avg_bitrate", prop->avg_bitrate);
- print_int("buffer_size", prop->buffer_size);
- print_int("vbv_delay", prop->vbv_delay);
- } else if (sd->type == AV_PKT_DATA_WEBVTT_IDENTIFIER ||
- sd->type == AV_PKT_DATA_WEBVTT_SETTINGS) {
- if (do_show_data)
- writer_print_data(w, "data", sd->data, sd->size);
- writer_print_data_hash(w, "data_hash", sd->data, sd->size);
- } else if (sd->type == AV_PKT_DATA_AFD && sd->size > 0) {
- print_int("active_format", *sd->data);
- }
- writer_print_section_footer(w);
- }
- writer_print_section_footer(w);
-}
-
-static void print_color_range(WriterContext *w, enum AVColorRange color_range)
-{
- const char *val = av_color_range_name(color_range);
- if (!val || color_range == AVCOL_RANGE_UNSPECIFIED) {
- print_str_opt("color_range", "unknown");
- } else {
- print_str("color_range", val);
- }
-}
-
-static void print_color_space(WriterContext *w, enum AVColorSpace color_space)
-{
- const char *val = av_color_space_name(color_space);
- if (!val || color_space == AVCOL_SPC_UNSPECIFIED) {
- print_str_opt("color_space", "unknown");
- } else {
- print_str("color_space", val);
- }
-}
-
-static void print_primaries(WriterContext *w, enum AVColorPrimaries color_primaries)
-{
- const char *val = av_color_primaries_name(color_primaries);
- if (!val || color_primaries == AVCOL_PRI_UNSPECIFIED) {
- print_str_opt("color_primaries", "unknown");
- } else {
- print_str("color_primaries", val);
- }
-}
-
-static void print_color_trc(WriterContext *w, enum AVColorTransferCharacteristic color_trc)
-{
- const char *val = av_color_transfer_name(color_trc);
- if (!val || color_trc == AVCOL_TRC_UNSPECIFIED) {
- print_str_opt("color_transfer", "unknown");
- } else {
- print_str("color_transfer", val);
- }
-}
-
-static void print_chroma_location(WriterContext *w, enum AVChromaLocation chroma_location)
-{
- const char *val = av_chroma_location_name(chroma_location);
- if (!val || chroma_location == AVCHROMA_LOC_UNSPECIFIED) {
- print_str_opt("chroma_location", "unspecified");
- } else {
- print_str("chroma_location", val);
- }
-}
-
-
-static void clear_log(int need_lock)
-{
- int i;
-
- if (need_lock)
- pthread_mutex_lock(&log_mutex);
- for (i=0; istreams[pkt->stream_index].st;
- AVBPrint pbuf;
- const char *s;
-
- av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
-
- writer_print_section_header(w, SECTION_ID_PACKET);
-
- s = av_get_media_type_string(st->codecpar->codec_type);
- if (s) print_str ("codec_type", s);
- else print_str_opt("codec_type", "unknown");
- print_int("stream_index", pkt->stream_index);
- print_ts ("pts", pkt->pts);
- print_time("pts_time", pkt->pts, &st->time_base);
- print_ts ("dts", pkt->dts);
- print_time("dts_time", pkt->dts, &st->time_base);
- print_duration_ts("duration", pkt->duration);
- print_duration_time("duration_time", pkt->duration, &st->time_base);
- print_val("size", pkt->size, unit_byte_str);
- if (pkt->pos != -1) print_fmt ("pos", "%"PRId64, pkt->pos);
- else print_str_opt("pos", "N/A");
- print_fmt("flags", "%c%c%c", pkt->flags & AV_PKT_FLAG_KEY ? 'K' : '_',
- pkt->flags & AV_PKT_FLAG_DISCARD ? 'D' : '_',
- pkt->flags & AV_PKT_FLAG_CORRUPT ? 'C' : '_');
- if (do_show_data)
- writer_print_data(w, "data", pkt->data, pkt->size);
- writer_print_data_hash(w, "data_hash", pkt->data, pkt->size);
-
- if (pkt->side_data_elems) {
- size_t size;
- const uint8_t *side_metadata;
-
- side_metadata = av_packet_get_side_data(pkt, AV_PKT_DATA_STRINGS_METADATA, &size);
- if (side_metadata && size && do_show_packet_tags) {
- AVDictionary *dict = NULL;
- if (av_packet_unpack_dictionary(side_metadata, size, &dict) >= 0)
- show_tags(w, dict, SECTION_ID_PACKET_TAGS);
- av_dict_free(&dict);
- }
-
- print_pkt_side_data(w, st->codecpar, pkt->side_data, pkt->side_data_elems,
- SECTION_ID_PACKET_SIDE_DATA_LIST,
- SECTION_ID_PACKET_SIDE_DATA);
- }
-
- writer_print_section_footer(w);
-
- av_bprint_finalize(&pbuf, NULL);
- fflush(stdout);
-}
-
-static void show_subtitle(WriterContext *w, AVSubtitle *sub, AVStream *stream,
- AVFormatContext *fmt_ctx)
-{
- AVBPrint pbuf;
-
- av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
-
- writer_print_section_header(w, SECTION_ID_SUBTITLE);
-
- print_str ("media_type", "subtitle");
- print_ts ("pts", sub->pts);
- print_time("pts_time", sub->pts, &AV_TIME_BASE_Q);
- print_int ("format", sub->format);
- print_int ("start_display_time", sub->start_display_time);
- print_int ("end_display_time", sub->end_display_time);
- print_int ("num_rects", sub->num_rects);
-
- writer_print_section_footer(w);
-
- av_bprint_finalize(&pbuf, NULL);
- fflush(stdout);
-}
-
-static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream,
- AVFormatContext *fmt_ctx)
-{
- FrameData *fd = frame->opaque_ref ? (FrameData*)frame->opaque_ref->data : NULL;
- AVBPrint pbuf;
- char val_str[128];
- const char *s;
- int i;
-
- av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
-
- writer_print_section_header(w, SECTION_ID_FRAME);
-
- s = av_get_media_type_string(stream->codecpar->codec_type);
- if (s) print_str ("media_type", s);
- else print_str_opt("media_type", "unknown");
- print_int("stream_index", stream->index);
- print_int("key_frame", frame->key_frame);
- print_ts ("pts", frame->pts);
- print_time("pts_time", frame->pts, &stream->time_base);
- print_ts ("pkt_dts", frame->pkt_dts);
- print_time("pkt_dts_time", frame->pkt_dts, &stream->time_base);
- print_ts ("best_effort_timestamp", frame->best_effort_timestamp);
- print_time("best_effort_timestamp_time", frame->best_effort_timestamp, &stream->time_base);
-#if LIBAVUTIL_VERSION_MAJOR < 59
- AV_NOWARN_DEPRECATED(
- print_duration_ts ("pkt_duration", frame->pkt_duration);
- print_duration_time("pkt_duration_time", frame->pkt_duration, &stream->time_base);
- )
-#endif
- print_duration_ts ("duration", frame->duration);
- print_duration_time("duration_time", frame->duration, &stream->time_base);
- if (fd && fd->pkt_pos != -1) print_fmt ("pkt_pos", "%"PRId64, fd->pkt_pos);
- else print_str_opt("pkt_pos", "N/A");
- if (fd && fd->pkt_size != -1) print_val ("pkt_size", fd->pkt_size, unit_byte_str);
- else print_str_opt("pkt_size", "N/A");
-
- switch (stream->codecpar->codec_type) {
- AVRational sar;
-
- case AVMEDIA_TYPE_VIDEO:
- print_int("width", frame->width);
- print_int("height", frame->height);
- print_int("crop_top", frame->crop_top);
- print_int("crop_bottom", frame->crop_bottom);
- print_int("crop_left", frame->crop_left);
- print_int("crop_right", frame->crop_right);
- s = av_get_pix_fmt_name(frame->format);
- if (s) print_str ("pix_fmt", s);
- else print_str_opt("pix_fmt", "unknown");
- sar = av_guess_sample_aspect_ratio(fmt_ctx, stream, frame);
- if (sar.num) {
- print_q("sample_aspect_ratio", sar, ':');
- } else {
- print_str_opt("sample_aspect_ratio", "N/A");
- }
- print_fmt("pict_type", "%c", av_get_picture_type_char(frame->pict_type));
-#if LIBAVUTIL_VERSION_MAJOR < 59
- AV_NOWARN_DEPRECATED(
- print_int("coded_picture_number", frame->coded_picture_number);
- print_int("display_picture_number", frame->display_picture_number);
- )
-#endif
- print_int("interlaced_frame", frame->interlaced_frame);
- print_int("top_field_first", frame->top_field_first);
- print_int("repeat_pict", frame->repeat_pict);
-
- print_color_range(w, frame->color_range);
- print_color_space(w, frame->colorspace);
- print_primaries(w, frame->color_primaries);
- print_color_trc(w, frame->color_trc);
- print_chroma_location(w, frame->chroma_location);
- break;
-
- case AVMEDIA_TYPE_AUDIO:
- s = av_get_sample_fmt_name(frame->format);
- if (s) print_str ("sample_fmt", s);
- else print_str_opt("sample_fmt", "unknown");
- print_int("nb_samples", frame->nb_samples);
- print_int("channels", frame->ch_layout.nb_channels);
- if (frame->ch_layout.order != AV_CHANNEL_ORDER_UNSPEC) {
- av_channel_layout_describe(&frame->ch_layout, val_str, sizeof(val_str));
- print_str ("channel_layout", val_str);
- } else
- print_str_opt("channel_layout", "unknown");
- break;
- }
- if (do_show_frame_tags)
- show_tags(w, frame->metadata, SECTION_ID_FRAME_TAGS);
- if (do_show_log)
- show_log(w, SECTION_ID_FRAME_LOGS, SECTION_ID_FRAME_LOG, do_show_log);
- if (frame->nb_side_data) {
- writer_print_section_header(w, SECTION_ID_FRAME_SIDE_DATA_LIST);
- for (i = 0; i < frame->nb_side_data; i++) {
- AVFrameSideData *sd = frame->side_data[i];
- const char *name;
-
- writer_print_section_header(w, SECTION_ID_FRAME_SIDE_DATA);
- name = av_frame_side_data_name(sd->type);
- print_str("side_data_type", name ? name : "unknown");
- if (sd->type == AV_FRAME_DATA_DISPLAYMATRIX && sd->size >= 9*4) {
- double rotation = av_display_rotation_get((int32_t *)sd->data);
- if (isnan(rotation))
- rotation = 0;
- writer_print_integers(w, "displaymatrix", sd->data, 9, " %11d", 3, 4, 1);
- print_int("rotation", rotation);
- } else if (sd->type == AV_FRAME_DATA_AFD && sd->size > 0) {
- print_int("active_format", *sd->data);
- } else if (sd->type == AV_FRAME_DATA_GOP_TIMECODE && sd->size >= 8) {
- char tcbuf[AV_TIMECODE_STR_SIZE];
- av_timecode_make_mpeg_tc_string(tcbuf, *(int64_t *)(sd->data));
- print_str("timecode", tcbuf);
- } else if (sd->type == AV_FRAME_DATA_S12M_TIMECODE && sd->size == 16) {
- uint32_t *tc = (uint32_t*)sd->data;
- int m = FFMIN(tc[0],3);
- writer_print_section_header(w, SECTION_ID_FRAME_SIDE_DATA_TIMECODE_LIST);
- for (int j = 1; j <= m ; j++) {
- char tcbuf[AV_TIMECODE_STR_SIZE];
- av_timecode_make_smpte_tc_string2(tcbuf, stream->avg_frame_rate, tc[j], 0, 0);
- writer_print_section_header(w, SECTION_ID_FRAME_SIDE_DATA_TIMECODE);
- print_str("value", tcbuf);
- writer_print_section_footer(w);
- }
- writer_print_section_footer(w);
- } else if (sd->type == AV_FRAME_DATA_MASTERING_DISPLAY_METADATA) {
- AVMasteringDisplayMetadata *metadata = (AVMasteringDisplayMetadata *)sd->data;
-
- if (metadata->has_primaries) {
- print_q("red_x", metadata->display_primaries[0][0], '/');
- print_q("red_y", metadata->display_primaries[0][1], '/');
- print_q("green_x", metadata->display_primaries[1][0], '/');
- print_q("green_y", metadata->display_primaries[1][1], '/');
- print_q("blue_x", metadata->display_primaries[2][0], '/');
- print_q("blue_y", metadata->display_primaries[2][1], '/');
-
- print_q("white_point_x", metadata->white_point[0], '/');
- print_q("white_point_y", metadata->white_point[1], '/');
- }
-
- if (metadata->has_luminance) {
- print_q("min_luminance", metadata->min_luminance, '/');
- print_q("max_luminance", metadata->max_luminance, '/');
- }
- } else if (sd->type == AV_FRAME_DATA_DYNAMIC_HDR_PLUS) {
- AVDynamicHDRPlus *metadata = (AVDynamicHDRPlus *)sd->data;
- print_dynamic_hdr10_plus(w, metadata);
- } else if (sd->type == AV_FRAME_DATA_CONTENT_LIGHT_LEVEL) {
- AVContentLightMetadata *metadata = (AVContentLightMetadata *)sd->data;
- print_int("max_content", metadata->MaxCLL);
- print_int("max_average", metadata->MaxFALL);
- } else if (sd->type == AV_FRAME_DATA_ICC_PROFILE) {
- const AVDictionaryEntry *tag = av_dict_get(sd->metadata, "name", NULL, AV_DICT_MATCH_CASE);
- if (tag)
- print_str(tag->key, tag->value);
- print_int("size", sd->size);
- } else if (sd->type == AV_FRAME_DATA_DOVI_METADATA) {
- print_dovi_metadata(w, (const AVDOVIMetadata *)sd->data);
- } else if (sd->type == AV_FRAME_DATA_DYNAMIC_HDR_VIVID) {
- AVDynamicHDRVivid *metadata = (AVDynamicHDRVivid *)sd->data;
- print_dynamic_hdr_vivid(w, metadata);
- } else if (sd->type == AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT) {
- print_ambient_viewing_environment(
- w, (const AVAmbientViewingEnvironment *)sd->data);
- }
- writer_print_section_footer(w);
- }
- writer_print_section_footer(w);
- }
-
- writer_print_section_footer(w);
-
- av_bprint_finalize(&pbuf, NULL);
- fflush(stdout);
-}
-
-static av_always_inline int process_frame(WriterContext *w,
- InputFile *ifile,
- AVFrame *frame, const AVPacket *pkt,
- int *packet_new)
-{
- AVFormatContext *fmt_ctx = ifile->fmt_ctx;
- AVCodecContext *dec_ctx = ifile->streams[pkt->stream_index].dec_ctx;
- AVCodecParameters *par = ifile->streams[pkt->stream_index].st->codecpar;
- AVSubtitle sub;
- int ret = 0, got_frame = 0;
-
- clear_log(1);
- if (dec_ctx) {
- switch (par->codec_type) {
- case AVMEDIA_TYPE_VIDEO:
- case AVMEDIA_TYPE_AUDIO:
- if (*packet_new) {
- ret = avcodec_send_packet(dec_ctx, pkt);
- if (ret == AVERROR(EAGAIN)) {
- ret = 0;
- } else if (ret >= 0 || ret == AVERROR_EOF) {
- ret = 0;
- *packet_new = 0;
- }
- }
- if (ret >= 0) {
- ret = avcodec_receive_frame(dec_ctx, frame);
- if (ret >= 0) {
- got_frame = 1;
- } else if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
- ret = 0;
- }
- }
- break;
-
- case AVMEDIA_TYPE_SUBTITLE:
- if (*packet_new)
- ret = avcodec_decode_subtitle2(dec_ctx, &sub, &got_frame, pkt);
- *packet_new = 0;
- break;
- default:
- *packet_new = 0;
- }
- } else {
- *packet_new = 0;
- }
-
- if (ret < 0)
- return ret;
- if (got_frame) {
- int is_sub = (par->codec_type == AVMEDIA_TYPE_SUBTITLE);
- nb_streams_frames[pkt->stream_index]++;
- if (do_show_frames)
- if (is_sub)
- show_subtitle(w, &sub, ifile->streams[pkt->stream_index].st, fmt_ctx);
- else
- show_frame(w, frame, ifile->streams[pkt->stream_index].st, fmt_ctx);
- if (is_sub)
- avsubtitle_free(&sub);
- }
- return got_frame || *packet_new;
-}
-
-static void log_read_interval(const ReadInterval *interval, void *log_ctx, int log_level)
-{
- av_log(log_ctx, log_level, "id:%d", interval->id);
-
- if (interval->has_start) {
- av_log(log_ctx, log_level, " start:%s%s", interval->start_is_offset ? "+" : "",
- av_ts2timestr(interval->start, &AV_TIME_BASE_Q));
- } else {
- av_log(log_ctx, log_level, " start:N/A");
- }
-
- if (interval->has_end) {
- av_log(log_ctx, log_level, " end:%s", interval->end_is_offset ? "+" : "");
- if (interval->duration_frames)
- av_log(log_ctx, log_level, "#%"PRId64, interval->end);
- else
- av_log(log_ctx, log_level, "%s", av_ts2timestr(interval->end, &AV_TIME_BASE_Q));
- } else {
- av_log(log_ctx, log_level, " end:N/A");
- }
-
- av_log(log_ctx, log_level, "\n");
-}
-
-static int read_interval_packets(WriterContext *w, InputFile *ifile,
- const ReadInterval *interval, int64_t *cur_ts)
-{
- AVFormatContext *fmt_ctx = ifile->fmt_ctx;
- AVPacket *pkt = NULL;
- AVFrame *frame = NULL;
- int ret = 0, i = 0, frame_count = 0;
- int64_t start = -INT64_MAX, end = interval->end;
- int has_start = 0, has_end = interval->has_end && !interval->end_is_offset;
-
- av_log(NULL, AV_LOG_VERBOSE, "Processing read interval ");
- log_read_interval(interval, NULL, AV_LOG_VERBOSE);
-
- if (interval->has_start) {
- int64_t target;
- if (interval->start_is_offset) {
- if (*cur_ts == AV_NOPTS_VALUE) {
- av_log(NULL, AV_LOG_ERROR,
- "Could not seek to relative position since current "
- "timestamp is not defined\n");
- ret = AVERROR(EINVAL);
- goto end;
- }
- target = *cur_ts + interval->start;
- } else {
- target = interval->start;
- }
-
- av_log(NULL, AV_LOG_VERBOSE, "Seeking to read interval start point %s\n",
- av_ts2timestr(target, &AV_TIME_BASE_Q));
- if ((ret = avformat_seek_file(fmt_ctx, -1, -INT64_MAX, target, INT64_MAX, 0)) < 0) {
- av_log(NULL, AV_LOG_ERROR, "Could not seek to position %"PRId64": %s\n",
- interval->start, av_err2str(ret));
- goto end;
- }
- }
-
- frame = av_frame_alloc();
- if (!frame) {
- ret = AVERROR(ENOMEM);
- goto end;
- }
- pkt = av_packet_alloc();
- if (!pkt) {
- ret = AVERROR(ENOMEM);
- goto end;
- }
- while (!av_read_frame(fmt_ctx, pkt)) {
- if (fmt_ctx->nb_streams > nb_streams) {
- REALLOCZ_ARRAY_STREAM(nb_streams_frames, nb_streams, fmt_ctx->nb_streams);
- REALLOCZ_ARRAY_STREAM(nb_streams_packets, nb_streams, fmt_ctx->nb_streams);
- REALLOCZ_ARRAY_STREAM(selected_streams, nb_streams, fmt_ctx->nb_streams);
- nb_streams = fmt_ctx->nb_streams;
- }
- if (selected_streams[pkt->stream_index]) {
- AVRational tb = ifile->streams[pkt->stream_index].st->time_base;
- int64_t pts = pkt->pts != AV_NOPTS_VALUE ? pkt->pts : pkt->dts;
-
- if (pts != AV_NOPTS_VALUE)
- *cur_ts = av_rescale_q(pts, tb, AV_TIME_BASE_Q);
-
- if (!has_start && *cur_ts != AV_NOPTS_VALUE) {
- start = *cur_ts;
- has_start = 1;
- }
-
- if (has_start && !has_end && interval->end_is_offset) {
- end = start + interval->end;
- has_end = 1;
- }
-
- if (interval->end_is_offset && interval->duration_frames) {
- if (frame_count >= interval->end)
- break;
- } else if (has_end && *cur_ts != AV_NOPTS_VALUE && *cur_ts >= end) {
- break;
- }
-
- frame_count++;
- if (do_read_packets) {
- if (do_show_packets)
- show_packet(w, ifile, pkt, i++);
- nb_streams_packets[pkt->stream_index]++;
- }
- if (do_read_frames) {
- int packet_new = 1;
- FrameData *fd;
-
- pkt->opaque_ref = av_buffer_allocz(sizeof(*fd));
- if (!pkt->opaque_ref)
- return AVERROR(ENOMEM);
- fd = (FrameData*)pkt->opaque_ref->data;
- fd->pkt_pos = pkt->pos;
- fd->pkt_size = pkt->size;
-
- while (process_frame(w, ifile, frame, pkt, &packet_new) > 0);
- }
- }
- av_packet_unref(pkt);
- }
- av_packet_unref(pkt);
- //Flush remaining frames that are cached in the decoder
- for (i = 0; i < ifile->nb_streams; i++) {
- pkt->stream_index = i;
- if (do_read_frames) {
- while (process_frame(w, ifile, frame, pkt, &(int){1}) > 0);
- if (ifile->streams[i].dec_ctx)
- avcodec_flush_buffers(ifile->streams[i].dec_ctx);
- }
- }
-
-end:
- av_frame_free(&frame);
- av_packet_free(&pkt);
- if (ret < 0) {
- av_log(NULL, AV_LOG_ERROR, "Could not read packets in interval ");
- log_read_interval(interval, NULL, AV_LOG_ERROR);
- }
- return ret;
-}
-
-static int read_packets(WriterContext *w, InputFile *ifile)
-{
- AVFormatContext *fmt_ctx = ifile->fmt_ctx;
- int i, ret = 0;
- int64_t cur_ts = fmt_ctx->start_time;
-
- if (read_intervals_nb == 0) {
- ReadInterval interval = (ReadInterval) { .has_start = 0, .has_end = 0 };
- ret = read_interval_packets(w, ifile, &interval, &cur_ts);
- } else {
- for (i = 0; i < read_intervals_nb; i++) {
- ret = read_interval_packets(w, ifile, &read_intervals[i], &cur_ts);
- if (ret < 0)
- break;
- }
- }
-
- return ret;
-}
-
-static int show_stream(WriterContext *w, AVFormatContext *fmt_ctx, int stream_idx, InputStream *ist, int in_program)
-{
- AVStream *stream = ist->st;
- AVCodecParameters *par;
- AVCodecContext *dec_ctx;
- char val_str[128];
- const char *s;
- AVRational sar, dar;
- AVBPrint pbuf;
- const AVCodecDescriptor *cd;
- int ret = 0;
- const char *profile = NULL;
-
- av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
-
- writer_print_section_header(w, in_program ? SECTION_ID_PROGRAM_STREAM : SECTION_ID_STREAM);
-
- print_int("index", stream->index);
-
- par = stream->codecpar;
- dec_ctx = ist->dec_ctx;
- if (cd = avcodec_descriptor_get(par->codec_id)) {
- print_str("codec_name", cd->name);
- if (!do_bitexact) {
- print_str("codec_long_name",
- cd->long_name ? cd->long_name : "unknown");
- }
- } else {
- print_str_opt("codec_name", "unknown");
- if (!do_bitexact) {
- print_str_opt("codec_long_name", "unknown");
- }
- }
-
- if (!do_bitexact && (profile = avcodec_profile_name(par->codec_id, par->profile)))
- print_str("profile", profile);
- else {
- if (par->profile != FF_PROFILE_UNKNOWN) {
- char profile_num[12];
- snprintf(profile_num, sizeof(profile_num), "%d", par->profile);
- print_str("profile", profile_num);
- } else
- print_str_opt("profile", "unknown");
- }
-
- s = av_get_media_type_string(par->codec_type);
- if (s) print_str ("codec_type", s);
- else print_str_opt("codec_type", "unknown");
-
- /* print AVI/FourCC tag */
- print_str("codec_tag_string", av_fourcc2str(par->codec_tag));
- print_fmt("codec_tag", "0x%04"PRIx32, par->codec_tag);
-
- switch (par->codec_type) {
- case AVMEDIA_TYPE_VIDEO:
- print_int("width", par->width);
- print_int("height", par->height);
- if (dec_ctx) {
- print_int("coded_width", dec_ctx->coded_width);
- print_int("coded_height", dec_ctx->coded_height);
- print_int("closed_captions", !!(dec_ctx->properties & FF_CODEC_PROPERTY_CLOSED_CAPTIONS));
- print_int("film_grain", !!(dec_ctx->properties & FF_CODEC_PROPERTY_FILM_GRAIN));
- }
- print_int("has_b_frames", par->video_delay);
- sar = av_guess_sample_aspect_ratio(fmt_ctx, stream, NULL);
- if (sar.num) {
- print_q("sample_aspect_ratio", sar, ':');
- av_reduce(&dar.num, &dar.den,
- par->width * sar.num,
- par->height * sar.den,
- 1024*1024);
- print_q("display_aspect_ratio", dar, ':');
- } else {
- print_str_opt("sample_aspect_ratio", "N/A");
- print_str_opt("display_aspect_ratio", "N/A");
- }
- s = av_get_pix_fmt_name(par->format);
- if (s) print_str ("pix_fmt", s);
- else print_str_opt("pix_fmt", "unknown");
- print_int("level", par->level);
-
- print_color_range(w, par->color_range);
- print_color_space(w, par->color_space);
- print_color_trc(w, par->color_trc);
- print_primaries(w, par->color_primaries);
- print_chroma_location(w, par->chroma_location);
-
- if (par->field_order == AV_FIELD_PROGRESSIVE)
- print_str("field_order", "progressive");
- else if (par->field_order == AV_FIELD_TT)
- print_str("field_order", "tt");
- else if (par->field_order == AV_FIELD_BB)
- print_str("field_order", "bb");
- else if (par->field_order == AV_FIELD_TB)
- print_str("field_order", "tb");
- else if (par->field_order == AV_FIELD_BT)
- print_str("field_order", "bt");
- else
- print_str_opt("field_order", "unknown");
-
- if (dec_ctx)
- print_int("refs", dec_ctx->refs);
- break;
-
- case AVMEDIA_TYPE_AUDIO:
- s = av_get_sample_fmt_name(par->format);
- if (s) print_str ("sample_fmt", s);
- else print_str_opt("sample_fmt", "unknown");
- print_val("sample_rate", par->sample_rate, unit_hertz_str);
- print_int("channels", par->ch_layout.nb_channels);
-
- if (par->ch_layout.order != AV_CHANNEL_ORDER_UNSPEC) {
- av_channel_layout_describe(&par->ch_layout, val_str, sizeof(val_str));
- print_str ("channel_layout", val_str);
- } else {
- print_str_opt("channel_layout", "unknown");
- }
-
- print_int("bits_per_sample", av_get_bits_per_sample(par->codec_id));
-
- print_int("initial_padding", par->initial_padding);
- break;
-
- case AVMEDIA_TYPE_SUBTITLE:
- if (par->width)
- print_int("width", par->width);
- else
- print_str_opt("width", "N/A");
- if (par->height)
- print_int("height", par->height);
- else
- print_str_opt("height", "N/A");
- break;
- }
-
- if (dec_ctx && dec_ctx->codec->priv_class && show_private_data) {
- const AVOption *opt = NULL;
- while (opt = av_opt_next(dec_ctx->priv_data,opt)) {
- uint8_t *str;
- if (!(opt->flags & AV_OPT_FLAG_EXPORT)) continue;
- if (av_opt_get(dec_ctx->priv_data, opt->name, 0, &str) >= 0) {
- print_str(opt->name, str);
- av_free(str);
- }
- }
- }
-
- if (fmt_ctx->iformat->flags & AVFMT_SHOW_IDS) print_fmt ("id", "0x%x", stream->id);
- else print_str_opt("id", "N/A");
- print_q("r_frame_rate", stream->r_frame_rate, '/');
- print_q("avg_frame_rate", stream->avg_frame_rate, '/');
- print_q("time_base", stream->time_base, '/');
- print_ts ("start_pts", stream->start_time);
- print_time("start_time", stream->start_time, &stream->time_base);
- print_ts ("duration_ts", stream->duration);
- print_time("duration", stream->duration, &stream->time_base);
- if (par->bit_rate > 0) print_val ("bit_rate", par->bit_rate, unit_bit_per_second_str);
- else print_str_opt("bit_rate", "N/A");
- if (dec_ctx && dec_ctx->rc_max_rate > 0)
- print_val ("max_bit_rate", dec_ctx->rc_max_rate, unit_bit_per_second_str);
- else
- print_str_opt("max_bit_rate", "N/A");
- if (dec_ctx && dec_ctx->bits_per_raw_sample > 0) print_fmt("bits_per_raw_sample", "%d", dec_ctx->bits_per_raw_sample);
- else print_str_opt("bits_per_raw_sample", "N/A");
- if (stream->nb_frames) print_fmt ("nb_frames", "%"PRId64, stream->nb_frames);
- else print_str_opt("nb_frames", "N/A");
- if (nb_streams_frames[stream_idx]) print_fmt ("nb_read_frames", "%"PRIu64, nb_streams_frames[stream_idx]);
- else print_str_opt("nb_read_frames", "N/A");
- if (nb_streams_packets[stream_idx]) print_fmt ("nb_read_packets", "%"PRIu64, nb_streams_packets[stream_idx]);
- else print_str_opt("nb_read_packets", "N/A");
- if (do_show_data)
- writer_print_data(w, "extradata", par->extradata,
- par->extradata_size);
-
- if (par->extradata_size > 0) {
- print_int("extradata_size", par->extradata_size);
- writer_print_data_hash(w, "extradata_hash", par->extradata,
- par->extradata_size);
- }
-
- /* Print disposition information */
-#define PRINT_DISPOSITION(flagname, name) do { \
- print_int(name, !!(stream->disposition & AV_DISPOSITION_##flagname)); \
- } while (0)
-
- if (do_show_stream_disposition) {
- writer_print_section_header(w, in_program ? SECTION_ID_PROGRAM_STREAM_DISPOSITION : SECTION_ID_STREAM_DISPOSITION);
- PRINT_DISPOSITION(DEFAULT, "default");
- PRINT_DISPOSITION(DUB, "dub");
- PRINT_DISPOSITION(ORIGINAL, "original");
- PRINT_DISPOSITION(COMMENT, "comment");
- PRINT_DISPOSITION(LYRICS, "lyrics");
- PRINT_DISPOSITION(KARAOKE, "karaoke");
- PRINT_DISPOSITION(FORCED, "forced");
- PRINT_DISPOSITION(HEARING_IMPAIRED, "hearing_impaired");
- PRINT_DISPOSITION(VISUAL_IMPAIRED, "visual_impaired");
- PRINT_DISPOSITION(CLEAN_EFFECTS, "clean_effects");
- PRINT_DISPOSITION(ATTACHED_PIC, "attached_pic");
- PRINT_DISPOSITION(TIMED_THUMBNAILS, "timed_thumbnails");
- PRINT_DISPOSITION(CAPTIONS, "captions");
- PRINT_DISPOSITION(DESCRIPTIONS, "descriptions");
- PRINT_DISPOSITION(METADATA, "metadata");
- PRINT_DISPOSITION(DEPENDENT, "dependent");
- PRINT_DISPOSITION(STILL_IMAGE, "still_image");
- writer_print_section_footer(w);
- }
-
- if (do_show_stream_tags)
- ret = show_tags(w, stream->metadata, in_program ? SECTION_ID_PROGRAM_STREAM_TAGS : SECTION_ID_STREAM_TAGS);
-
- if (stream->nb_side_data) {
- print_pkt_side_data(w, stream->codecpar, stream->side_data, stream->nb_side_data,
- SECTION_ID_STREAM_SIDE_DATA_LIST,
- SECTION_ID_STREAM_SIDE_DATA);
- }
-
- writer_print_section_footer(w);
- av_bprint_finalize(&pbuf, NULL);
- fflush(stdout);
-
- return ret;
-}
-
-static int show_streams(WriterContext *w, InputFile *ifile)
-{
- AVFormatContext *fmt_ctx = ifile->fmt_ctx;
- int i, ret = 0;
-
- writer_print_section_header(w, SECTION_ID_STREAMS);
- for (i = 0; i < ifile->nb_streams; i++)
- if (selected_streams[i]) {
- ret = show_stream(w, fmt_ctx, i, &ifile->streams[i], 0);
- if (ret < 0)
- break;
- }
- writer_print_section_footer(w);
-
- return ret;
-}
-
-static int show_program(WriterContext *w, InputFile *ifile, AVProgram *program)
-{
- AVFormatContext *fmt_ctx = ifile->fmt_ctx;
- int i, ret = 0;
-
- writer_print_section_header(w, SECTION_ID_PROGRAM);
- print_int("program_id", program->id);
- print_int("program_num", program->program_num);
- print_int("nb_streams", program->nb_stream_indexes);
- print_int("pmt_pid", program->pmt_pid);
- print_int("pcr_pid", program->pcr_pid);
- if (do_show_program_tags)
- ret = show_tags(w, program->metadata, SECTION_ID_PROGRAM_TAGS);
- if (ret < 0)
- goto end;
-
- writer_print_section_header(w, SECTION_ID_PROGRAM_STREAMS);
- for (i = 0; i < program->nb_stream_indexes; i++) {
- if (selected_streams[program->stream_index[i]]) {
- ret = show_stream(w, fmt_ctx, program->stream_index[i], &ifile->streams[program->stream_index[i]], 1);
- if (ret < 0)
- break;
- }
- }
- writer_print_section_footer(w);
-
-end:
- writer_print_section_footer(w);
- return ret;
-}
-
-static int show_programs(WriterContext *w, InputFile *ifile)
-{
- AVFormatContext *fmt_ctx = ifile->fmt_ctx;
- int i, ret = 0;
-
- writer_print_section_header(w, SECTION_ID_PROGRAMS);
- for (i = 0; i < fmt_ctx->nb_programs; i++) {
- AVProgram *program = fmt_ctx->programs[i];
- if (!program)
- continue;
- ret = show_program(w, ifile, program);
- if (ret < 0)
- break;
- }
- writer_print_section_footer(w);
- return ret;
-}
-
-static int show_chapters(WriterContext *w, InputFile *ifile)
-{
- AVFormatContext *fmt_ctx = ifile->fmt_ctx;
- int i, ret = 0;
-
- writer_print_section_header(w, SECTION_ID_CHAPTERS);
- for (i = 0; i < fmt_ctx->nb_chapters; i++) {
- AVChapter *chapter = fmt_ctx->chapters[i];
-
- writer_print_section_header(w, SECTION_ID_CHAPTER);
- print_int("id", chapter->id);
- print_q ("time_base", chapter->time_base, '/');
- print_int("start", chapter->start);
- print_time("start_time", chapter->start, &chapter->time_base);
- print_int("end", chapter->end);
- print_time("end_time", chapter->end, &chapter->time_base);
- if (do_show_chapter_tags)
- ret = show_tags(w, chapter->metadata, SECTION_ID_CHAPTER_TAGS);
- writer_print_section_footer(w);
- }
- writer_print_section_footer(w);
-
- return ret;
-}
-
-static int show_format(WriterContext *w, InputFile *ifile)
-{
- AVFormatContext *fmt_ctx = ifile->fmt_ctx;
- char val_str[128];
- int64_t size = fmt_ctx->pb ? avio_size(fmt_ctx->pb) : -1;
- int ret = 0;
-
- writer_print_section_header(w, SECTION_ID_FORMAT);
- print_str_validate("filename", fmt_ctx->url);
- print_int("nb_streams", fmt_ctx->nb_streams);
- print_int("nb_programs", fmt_ctx->nb_programs);
- print_str("format_name", fmt_ctx->iformat->name);
- if (!do_bitexact) {
- if (fmt_ctx->iformat->long_name) print_str ("format_long_name", fmt_ctx->iformat->long_name);
- else print_str_opt("format_long_name", "unknown");
- }
- print_time("start_time", fmt_ctx->start_time, &AV_TIME_BASE_Q);
- print_time("duration", fmt_ctx->duration, &AV_TIME_BASE_Q);
- if (size >= 0) print_val ("size", size, unit_byte_str);
- else print_str_opt("size", "N/A");
- if (fmt_ctx->bit_rate > 0) print_val ("bit_rate", fmt_ctx->bit_rate, unit_bit_per_second_str);
- else print_str_opt("bit_rate", "N/A");
- print_int("probe_score", fmt_ctx->probe_score);
- if (do_show_format_tags)
- ret = show_tags(w, fmt_ctx->metadata, SECTION_ID_FORMAT_TAGS);
-
- writer_print_section_footer(w);
- fflush(stdout);
- return ret;
-}
-
-static void show_error(WriterContext *w, int err)
-{
- writer_print_section_header(w, SECTION_ID_ERROR);
- print_int("code", err);
- print_str("string", av_err2str(err));
- writer_print_section_footer(w);
-}
-
-static int open_input_file(InputFile *ifile, const char *filename,
- const char *print_filename)
-{
- int err, i;
- AVFormatContext *fmt_ctx = NULL;
- const AVDictionaryEntry *t = NULL;
- int scan_all_pmts_set = 0;
-
- fmt_ctx = avformat_alloc_context();
- if (!fmt_ctx)
- report_and_exit(AVERROR(ENOMEM));
-
- if (!av_dict_get(format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
- av_dict_set(&format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
- scan_all_pmts_set = 1;
- }
- if ((err = avformat_open_input(&fmt_ctx, filename,
- iformat, &format_opts)) < 0) {
- print_error(filename, err);
- return err;
- }
- if (print_filename) {
- av_freep(&fmt_ctx->url);
- fmt_ctx->url = av_strdup(print_filename);
- }
- ifile->fmt_ctx = fmt_ctx;
- if (scan_all_pmts_set)
- av_dict_set(&format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
- while ((t = av_dict_iterate(format_opts, t)))
- av_log(NULL, AV_LOG_WARNING, "Option %s skipped - not known to demuxer.\n", t->key);
-
- if (find_stream_info) {
- AVDictionary **opts = setup_find_stream_info_opts(fmt_ctx, codec_opts);
- int orig_nb_streams = fmt_ctx->nb_streams;
-
- err = avformat_find_stream_info(fmt_ctx, opts);
-
- for (i = 0; i < orig_nb_streams; i++)
- av_dict_free(&opts[i]);
- av_freep(&opts);
-
- if (err < 0) {
- print_error(filename, err);
- return err;
- }
- }
-
- av_dump_format(fmt_ctx, 0, filename, 0);
-
- ifile->streams = av_calloc(fmt_ctx->nb_streams, sizeof(*ifile->streams));
- if (!ifile->streams)
- exit(1);
- ifile->nb_streams = fmt_ctx->nb_streams;
-
- /* bind a decoder to each input stream */
- for (i = 0; i < fmt_ctx->nb_streams; i++) {
- InputStream *ist = &ifile->streams[i];
- AVStream *stream = fmt_ctx->streams[i];
- const AVCodec *codec;
-
- ist->st = stream;
-
- if (stream->codecpar->codec_id == AV_CODEC_ID_PROBE) {
- av_log(NULL, AV_LOG_WARNING,
- "Failed to probe codec for input stream %d\n",
- stream->index);
- continue;
- }
-
- codec = avcodec_find_decoder(stream->codecpar->codec_id);
- if (!codec) {
- av_log(NULL, AV_LOG_WARNING,
- "Unsupported codec with id %d for input stream %d\n",
- stream->codecpar->codec_id, stream->index);
- continue;
- }
- {
- AVDictionary *opts = filter_codec_opts(codec_opts, stream->codecpar->codec_id,
- fmt_ctx, stream, codec);
-
- ist->dec_ctx = avcodec_alloc_context3(codec);
- if (!ist->dec_ctx)
- exit(1);
-
- err = avcodec_parameters_to_context(ist->dec_ctx, stream->codecpar);
- if (err < 0)
- exit(1);
-
- if (do_show_log) {
- // For loging it is needed to disable at least frame threads as otherwise
- // the log information would need to be reordered and matches up to contexts and frames
- // That is in fact possible but not trivial
- av_dict_set(&codec_opts, "threads", "1", 0);
- }
-
- av_dict_set(&opts, "flags", "+copy_opaque", AV_DICT_MULTIKEY);
-
- ist->dec_ctx->pkt_timebase = stream->time_base;
-
- if (avcodec_open2(ist->dec_ctx, codec, &opts) < 0) {
- av_log(NULL, AV_LOG_WARNING, "Could not open codec for input stream %d\n",
- stream->index);
- exit(1);
- }
-
- if ((t = av_dict_get(opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
- av_log(NULL, AV_LOG_ERROR, "Option %s for input stream %d not found\n",
- t->key, stream->index);
- return AVERROR_OPTION_NOT_FOUND;
- }
- }
- }
-
- ifile->fmt_ctx = fmt_ctx;
- return 0;
-}
-
-static void close_input_file(InputFile *ifile)
-{
- int i;
-
- /* close decoder for each stream */
- for (i = 0; i < ifile->nb_streams; i++)
- avcodec_free_context(&ifile->streams[i].dec_ctx);
-
- av_freep(&ifile->streams);
- ifile->nb_streams = 0;
-
- avformat_close_input(&ifile->fmt_ctx);
-}
-
-static int probe_file(WriterContext *wctx, const char *filename,
- const char *print_filename)
-{
- InputFile ifile = { 0 };
- int ret, i;
- int section_id;
-
- do_read_frames = do_show_frames || do_count_frames;
- do_read_packets = do_show_packets || do_count_packets;
-
- ret = open_input_file(&ifile, filename, print_filename);
- if (ret < 0)
- goto end;
-
-#define CHECK_END if (ret < 0) goto end
-
- nb_streams = ifile.fmt_ctx->nb_streams;
- REALLOCZ_ARRAY_STREAM(nb_streams_frames,0,ifile.fmt_ctx->nb_streams);
- REALLOCZ_ARRAY_STREAM(nb_streams_packets,0,ifile.fmt_ctx->nb_streams);
- REALLOCZ_ARRAY_STREAM(selected_streams,0,ifile.fmt_ctx->nb_streams);
-
- for (i = 0; i < ifile.fmt_ctx->nb_streams; i++) {
- if (stream_specifier) {
- ret = avformat_match_stream_specifier(ifile.fmt_ctx,
- ifile.fmt_ctx->streams[i],
- stream_specifier);
- CHECK_END;
- else
- selected_streams[i] = ret;
- ret = 0;
- } else {
- selected_streams[i] = 1;
- }
- if (!selected_streams[i])
- ifile.fmt_ctx->streams[i]->discard = AVDISCARD_ALL;
- }
-
- if (do_read_frames || do_read_packets) {
- if (do_show_frames && do_show_packets &&
- wctx->writer->flags & WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER)
- section_id = SECTION_ID_PACKETS_AND_FRAMES;
- else if (do_show_packets && !do_show_frames)
- section_id = SECTION_ID_PACKETS;
- else // (!do_show_packets && do_show_frames)
- section_id = SECTION_ID_FRAMES;
- if (do_show_frames || do_show_packets)
- writer_print_section_header(wctx, section_id);
- ret = read_packets(wctx, &ifile);
- if (do_show_frames || do_show_packets)
- writer_print_section_footer(wctx);
- CHECK_END;
- }
-
- if (do_show_programs) {
- ret = show_programs(wctx, &ifile);
- CHECK_END;
- }
-
- if (do_show_streams) {
- ret = show_streams(wctx, &ifile);
- CHECK_END;
- }
- if (do_show_chapters) {
- ret = show_chapters(wctx, &ifile);
- CHECK_END;
- }
- if (do_show_format) {
- ret = show_format(wctx, &ifile);
- CHECK_END;
- }
-
-end:
- if (ifile.fmt_ctx)
- close_input_file(&ifile);
- av_freep(&nb_streams_frames);
- av_freep(&nb_streams_packets);
- av_freep(&selected_streams);
-
- return ret;
-}
-
-static void show_usage(void)
-{
- av_log(NULL, AV_LOG_INFO, "Simple multimedia streams analyzer\n");
- av_log(NULL, AV_LOG_INFO, "usage: %s [OPTIONS] INPUT_FILE\n", program_name);
- av_log(NULL, AV_LOG_INFO, "\n");
-}
-
-static void ffprobe_show_program_version(WriterContext *w)
-{
- AVBPrint pbuf;
- av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
-
- writer_print_section_header(w, SECTION_ID_PROGRAM_VERSION);
- print_str("version", FFMPEG_VERSION);
- print_fmt("copyright", "Copyright (c) %d-%d the FFmpeg developers",
- program_birth_year, CONFIG_THIS_YEAR);
- print_str("compiler_ident", CC_IDENT);
- print_str("configuration", FFMPEG_CONFIGURATION);
- writer_print_section_footer(w);
-
- av_bprint_finalize(&pbuf, NULL);
-}
-
-#define SHOW_LIB_VERSION(libname, LIBNAME) \
- do { \
- if (CONFIG_##LIBNAME) { \
- unsigned int version = libname##_version(); \
- writer_print_section_header(w, SECTION_ID_LIBRARY_VERSION); \
- print_str("name", "lib" #libname); \
- print_int("major", LIB##LIBNAME##_VERSION_MAJOR); \
- print_int("minor", LIB##LIBNAME##_VERSION_MINOR); \
- print_int("micro", LIB##LIBNAME##_VERSION_MICRO); \
- print_int("version", version); \
- print_str("ident", LIB##LIBNAME##_IDENT); \
- writer_print_section_footer(w); \
- } \
- } while (0)
-
-static void ffprobe_show_library_versions(WriterContext *w)
-{
- writer_print_section_header(w, SECTION_ID_LIBRARY_VERSIONS);
- SHOW_LIB_VERSION(avutil, AVUTIL);
- SHOW_LIB_VERSION(avcodec, AVCODEC);
- SHOW_LIB_VERSION(avformat, AVFORMAT);
- SHOW_LIB_VERSION(avdevice, AVDEVICE);
- SHOW_LIB_VERSION(avfilter, AVFILTER);
- SHOW_LIB_VERSION(swscale, SWSCALE);
- SHOW_LIB_VERSION(swresample, SWRESAMPLE);
- SHOW_LIB_VERSION(postproc, POSTPROC);
- writer_print_section_footer(w);
-}
-
-#define PRINT_PIX_FMT_FLAG(flagname, name) \
- do { \
- print_int(name, !!(pixdesc->flags & AV_PIX_FMT_FLAG_##flagname)); \
- } while (0)
-
-static void ffprobe_show_pixel_formats(WriterContext *w)
-{
- const AVPixFmtDescriptor *pixdesc = NULL;
- int i, n;
-
- writer_print_section_header(w, SECTION_ID_PIXEL_FORMATS);
- while (pixdesc = av_pix_fmt_desc_next(pixdesc)) {
- writer_print_section_header(w, SECTION_ID_PIXEL_FORMAT);
- print_str("name", pixdesc->name);
- print_int("nb_components", pixdesc->nb_components);
- if ((pixdesc->nb_components >= 3) && !(pixdesc->flags & AV_PIX_FMT_FLAG_RGB)) {
- print_int ("log2_chroma_w", pixdesc->log2_chroma_w);
- print_int ("log2_chroma_h", pixdesc->log2_chroma_h);
- } else {
- print_str_opt("log2_chroma_w", "N/A");
- print_str_opt("log2_chroma_h", "N/A");
- }
- n = av_get_bits_per_pixel(pixdesc);
- if (n) print_int ("bits_per_pixel", n);
- else print_str_opt("bits_per_pixel", "N/A");
- if (do_show_pixel_format_flags) {
- writer_print_section_header(w, SECTION_ID_PIXEL_FORMAT_FLAGS);
- PRINT_PIX_FMT_FLAG(BE, "big_endian");
- PRINT_PIX_FMT_FLAG(PAL, "palette");
- PRINT_PIX_FMT_FLAG(BITSTREAM, "bitstream");
- PRINT_PIX_FMT_FLAG(HWACCEL, "hwaccel");
- PRINT_PIX_FMT_FLAG(PLANAR, "planar");
- PRINT_PIX_FMT_FLAG(RGB, "rgb");
- PRINT_PIX_FMT_FLAG(ALPHA, "alpha");
- writer_print_section_footer(w);
- }
- if (do_show_pixel_format_components && (pixdesc->nb_components > 0)) {
- writer_print_section_header(w, SECTION_ID_PIXEL_FORMAT_COMPONENTS);
- for (i = 0; i < pixdesc->nb_components; i++) {
- writer_print_section_header(w, SECTION_ID_PIXEL_FORMAT_COMPONENT);
- print_int("index", i + 1);
- print_int("bit_depth", pixdesc->comp[i].depth);
- writer_print_section_footer(w);
- }
- writer_print_section_footer(w);
- }
- writer_print_section_footer(w);
- }
- writer_print_section_footer(w);
-}
-
-static int opt_show_optional_fields(void *optctx, const char *opt, const char *arg)
-{
- if (!av_strcasecmp(arg, "always")) show_optional_fields = SHOW_OPTIONAL_FIELDS_ALWAYS;
- else if (!av_strcasecmp(arg, "never")) show_optional_fields = SHOW_OPTIONAL_FIELDS_NEVER;
- else if (!av_strcasecmp(arg, "auto")) show_optional_fields = SHOW_OPTIONAL_FIELDS_AUTO;
-
- if (show_optional_fields == SHOW_OPTIONAL_FIELDS_AUTO && av_strcasecmp(arg, "auto"))
- show_optional_fields = parse_number_or_die("show_optional_fields", arg, OPT_INT, SHOW_OPTIONAL_FIELDS_AUTO, SHOW_OPTIONAL_FIELDS_ALWAYS);
- return 0;
-}
-
-static int opt_format(void *optctx, const char *opt, const char *arg)
-{
- iformat = av_find_input_format(arg);
- if (!iformat) {
- av_log(NULL, AV_LOG_ERROR, "Unknown input format: %s\n", arg);
- return AVERROR(EINVAL);
- }
- return 0;
-}
-
-static inline void mark_section_show_entries(SectionID section_id,
- int show_all_entries, AVDictionary *entries)
-{
- struct section *section = §ions[section_id];
-
- section->show_all_entries = show_all_entries;
- if (show_all_entries) {
- SectionID *id;
- for (id = section->children_ids; *id != -1; id++)
- mark_section_show_entries(*id, show_all_entries, entries);
- } else {
- av_dict_copy(§ion->entries_to_show, entries, 0);
- }
-}
-
-static int match_section(const char *section_name,
- int show_all_entries, AVDictionary *entries)
-{
- int i, ret = 0;
-
- for (i = 0; i < FF_ARRAY_ELEMS(sections); i++) {
- const struct section *section = §ions[i];
- if (!strcmp(section_name, section->name) ||
- (section->unique_name && !strcmp(section_name, section->unique_name))) {
- av_log(NULL, AV_LOG_DEBUG,
- "'%s' matches section with unique name '%s'\n", section_name,
- (char *)av_x_if_null(section->unique_name, section->name));
- ret++;
- mark_section_show_entries(section->id, show_all_entries, entries);
- }
- }
- return ret;
-}
-
-static int opt_show_entries(void *optctx, const char *opt, const char *arg)
-{
- const char *p = arg;
- int ret = 0;
-
- while (*p) {
- AVDictionary *entries = NULL;
- char *section_name = av_get_token(&p, "=:");
- int show_all_entries = 0;
-
- if (!section_name) {
- av_log(NULL, AV_LOG_ERROR,
- "Missing section name for option '%s'\n", opt);
- return AVERROR(EINVAL);
- }
-
- if (*p == '=') {
- p++;
- while (*p && *p != ':') {
- char *entry = av_get_token(&p, ",:");
- if (!entry)
- break;
- av_log(NULL, AV_LOG_VERBOSE,
- "Adding '%s' to the entries to show in section '%s'\n",
- entry, section_name);
- av_dict_set(&entries, entry, "", AV_DICT_DONT_STRDUP_KEY);
- if (*p == ',')
- p++;
- }
- } else {
- show_all_entries = 1;
- }
-
- ret = match_section(section_name, show_all_entries, entries);
- if (ret == 0) {
- av_log(NULL, AV_LOG_ERROR, "No match for section '%s'\n", section_name);
- ret = AVERROR(EINVAL);
- }
- av_dict_free(&entries);
- av_free(section_name);
-
- if (ret <= 0)
- break;
- if (*p)
- p++;
- }
-
- return ret;
-}
-
-static void opt_input_file(void *optctx, const char *arg)
-{
- if (input_filename) {
- av_log(NULL, AV_LOG_ERROR,
- "Argument '%s' provided as input filename, but '%s' was already specified.\n",
- arg, input_filename);
- exit_program(1);
- }
- if (!strcmp(arg, "-"))
- arg = "fd:";
- input_filename = arg;
-}
-
-static int opt_input_file_i(void *optctx, const char *opt, const char *arg)
-{
- opt_input_file(optctx, arg);
- return 0;
-}
-
-static void opt_output_file(void *optctx, const char *arg)
-{
- if (output_filename) {
- av_log(NULL, AV_LOG_ERROR,
- "Argument '%s' provided as output filename, but '%s' was already specified.\n",
- arg, output_filename);
- exit_program(1);
- }
- if (!strcmp(arg, "-"))
- arg = "fd:";
- output_filename = arg;
-}
-
-static int opt_output_file_o(void *optctx, const char *opt, const char *arg)
-{
- opt_output_file(optctx, arg);
- return 0;
-}
-
-static int opt_print_filename(void *optctx, const char *opt, const char *arg)
-{
- print_input_filename = arg;
- return 0;
-}
-
-void show_help_default(const char *opt, const char *arg)
-{
- av_log_set_callback(log_callback_help);
- show_usage();
- show_help_options(options, "Main options:", 0, 0, 0);
- printf("\n");
-
- show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
- show_help_children(avcodec_get_class(), AV_OPT_FLAG_DECODING_PARAM);
-}
-
-/**
- * Parse interval specification, according to the format:
- * INTERVAL ::= [START|+START_OFFSET][%[END|+END_OFFSET]]
- * INTERVALS ::= INTERVAL[,INTERVALS]
-*/
-static int parse_read_interval(const char *interval_spec,
- ReadInterval *interval)
-{
- int ret = 0;
- char *next, *p, *spec = av_strdup(interval_spec);
- if (!spec)
- return AVERROR(ENOMEM);
-
- if (!*spec) {
- av_log(NULL, AV_LOG_ERROR, "Invalid empty interval specification\n");
- ret = AVERROR(EINVAL);
- goto end;
- }
-
- p = spec;
- next = strchr(spec, '%');
- if (next)
- *next++ = 0;
-
- /* parse first part */
- if (*p) {
- interval->has_start = 1;
-
- if (*p == '+') {
- interval->start_is_offset = 1;
- p++;
- } else {
- interval->start_is_offset = 0;
- }
-
- ret = av_parse_time(&interval->start, p, 1);
- if (ret < 0) {
- av_log(NULL, AV_LOG_ERROR, "Invalid interval start specification '%s'\n", p);
- goto end;
- }
- } else {
- interval->has_start = 0;
- }
-
- /* parse second part */
- p = next;
- if (p && *p) {
- int64_t us;
- interval->has_end = 1;
-
- if (*p == '+') {
- interval->end_is_offset = 1;
- p++;
- } else {
- interval->end_is_offset = 0;
- }
-
- if (interval->end_is_offset && *p == '#') {
- long long int lli;
- char *tail;
- interval->duration_frames = 1;
- p++;
- lli = strtoll(p, &tail, 10);
- if (*tail || lli < 0) {
- av_log(NULL, AV_LOG_ERROR,
- "Invalid or negative value '%s' for duration number of frames\n", p);
- goto end;
- }
- interval->end = lli;
- } else {
- interval->duration_frames = 0;
- ret = av_parse_time(&us, p, 1);
- if (ret < 0) {
- av_log(NULL, AV_LOG_ERROR, "Invalid interval end/duration specification '%s'\n", p);
- goto end;
- }
- interval->end = us;
- }
- } else {
- interval->has_end = 0;
- }
-
-end:
- av_free(spec);
- return ret;
-}
-
-static int parse_read_intervals(const char *intervals_spec)
-{
- int ret, n, i;
- char *p, *spec = av_strdup(intervals_spec);
- if (!spec)
- return AVERROR(ENOMEM);
-
- /* preparse specification, get number of intervals */
- for (n = 0, p = spec; *p; p++)
- if (*p == ',')
- n++;
- n++;
-
- read_intervals = av_malloc_array(n, sizeof(*read_intervals));
- if (!read_intervals) {
- ret = AVERROR(ENOMEM);
- goto end;
- }
- read_intervals_nb = n;
-
- /* parse intervals */
- p = spec;
- for (i = 0; p; i++) {
- char *next;
-
- av_assert0(i < read_intervals_nb);
- next = strchr(p, ',');
- if (next)
- *next++ = 0;
-
- read_intervals[i].id = i;
- ret = parse_read_interval(p, &read_intervals[i]);
- if (ret < 0) {
- av_log(NULL, AV_LOG_ERROR, "Error parsing read interval #%d '%s'\n",
- i, p);
- goto end;
- }
- av_log(NULL, AV_LOG_VERBOSE, "Parsed log interval ");
- log_read_interval(&read_intervals[i], NULL, AV_LOG_VERBOSE);
- p = next;
- }
- av_assert0(i == read_intervals_nb);
-
-end:
- av_free(spec);
- return ret;
-}
-
-static int opt_read_intervals(void *optctx, const char *opt, const char *arg)
-{
- return parse_read_intervals(arg);
-}
-
-static int opt_pretty(void *optctx, const char *opt, const char *arg)
-{
- show_value_unit = 1;
- use_value_prefix = 1;
- use_byte_value_binary_prefix = 1;
- use_value_sexagesimal_format = 1;
- return 0;
-}
-
-static void print_section(SectionID id, int level)
-{
- const SectionID *pid;
- const struct section *section = §ions[id];
- printf("%c%c%c",
- section->flags & SECTION_FLAG_IS_WRAPPER ? 'W' : '.',
- section->flags & SECTION_FLAG_IS_ARRAY ? 'A' : '.',
- section->flags & SECTION_FLAG_HAS_VARIABLE_FIELDS ? 'V' : '.');
- printf("%*c %s", level * 4, ' ', section->name);
- if (section->unique_name)
- printf("/%s", section->unique_name);
- printf("\n");
-
- for (pid = section->children_ids; *pid != -1; pid++)
- print_section(*pid, level+1);
-}
-
-static int opt_sections(void *optctx, const char *opt, const char *arg)
-{
- printf("Sections:\n"
- "W.. = Section is a wrapper (contains other sections, no local entries)\n"
- ".A. = Section contains an array of elements of the same type\n"
- "..V = Section may contain a variable number of fields with variable keys\n"
- "FLAGS NAME/UNIQUE_NAME\n"
- "---\n");
- print_section(SECTION_ID_ROOT, 0);
- return 0;
-}
-
-static int opt_show_versions(void *optctx, const char *opt, const char *arg)
-{
- mark_section_show_entries(SECTION_ID_PROGRAM_VERSION, 1, NULL);
- mark_section_show_entries(SECTION_ID_LIBRARY_VERSION, 1, NULL);
- return 0;
-}
-
-#define DEFINE_OPT_SHOW_SECTION(section, target_section_id) \
- static int opt_show_##section(void *optctx, const char *opt, const char *arg) \
- { \
- mark_section_show_entries(SECTION_ID_##target_section_id, 1, NULL); \
- return 0; \
- }
-
-DEFINE_OPT_SHOW_SECTION(chapters, CHAPTERS)
-DEFINE_OPT_SHOW_SECTION(error, ERROR)
-DEFINE_OPT_SHOW_SECTION(format, FORMAT)
-DEFINE_OPT_SHOW_SECTION(frames, FRAMES)
-DEFINE_OPT_SHOW_SECTION(library_versions, LIBRARY_VERSIONS)
-DEFINE_OPT_SHOW_SECTION(packets, PACKETS)
-DEFINE_OPT_SHOW_SECTION(pixel_formats, PIXEL_FORMATS)
-DEFINE_OPT_SHOW_SECTION(program_version, PROGRAM_VERSION)
-DEFINE_OPT_SHOW_SECTION(streams, STREAMS)
-DEFINE_OPT_SHOW_SECTION(programs, PROGRAMS)
-
-static const OptionDef real_options[] = {
- CMDUTILS_COMMON_OPTIONS
- { "f", HAS_ARG, {.func_arg = opt_format}, "force format", "format" },
- { "unit", OPT_BOOL, {&show_value_unit}, "show unit of the displayed values" },
- { "prefix", OPT_BOOL, {&use_value_prefix}, "use SI prefixes for the displayed values" },
- { "byte_binary_prefix", OPT_BOOL, {&use_byte_value_binary_prefix},
- "use binary prefixes for byte units" },
- { "sexagesimal", OPT_BOOL, {&use_value_sexagesimal_format},
- "use sexagesimal format HOURS:MM:SS.MICROSECONDS for time units" },
- { "pretty", 0, {.func_arg = opt_pretty},
- "prettify the format of displayed values, make it more human readable" },
- { "print_format", OPT_STRING | HAS_ARG, { &print_format },
- "set the output printing format (available formats are: default, compact, csv, flat, ini, json, xml)", "format" },
- { "of", OPT_STRING | HAS_ARG, { &print_format }, "alias for -print_format", "format" },
- { "select_streams", OPT_STRING | HAS_ARG, { &stream_specifier }, "select the specified streams", "stream_specifier" },
- { "sections", OPT_EXIT, {.func_arg = opt_sections}, "print sections structure and section information, and exit" },
- { "show_data", OPT_BOOL, { &do_show_data }, "show packets data" },
- { "show_data_hash", OPT_STRING | HAS_ARG, { &show_data_hash }, "show packets data hash" },
- { "show_error", 0, { .func_arg = &opt_show_error }, "show probing error" },
- { "show_format", 0, { .func_arg = &opt_show_format }, "show format/container info" },
- { "show_frames", 0, { .func_arg = &opt_show_frames }, "show frames info" },
- { "show_entries", HAS_ARG, {.func_arg = opt_show_entries},
- "show a set of specified entries", "entry_list" },
-#if HAVE_THREADS
- { "show_log", OPT_INT|HAS_ARG, { &do_show_log }, "show log" },
-#endif
- { "show_packets", 0, { .func_arg = &opt_show_packets }, "show packets info" },
- { "show_programs", 0, { .func_arg = &opt_show_programs }, "show programs info" },
- { "show_streams", 0, { .func_arg = &opt_show_streams }, "show streams info" },
- { "show_chapters", 0, { .func_arg = &opt_show_chapters }, "show chapters info" },
- { "count_frames", OPT_BOOL, { &do_count_frames }, "count the number of frames per stream" },
- { "count_packets", OPT_BOOL, { &do_count_packets }, "count the number of packets per stream" },
- { "show_program_version", 0, { .func_arg = &opt_show_program_version }, "show ffprobe version" },
- { "show_library_versions", 0, { .func_arg = &opt_show_library_versions }, "show library versions" },
- { "show_versions", 0, { .func_arg = &opt_show_versions }, "show program and library versions" },
- { "show_pixel_formats", 0, { .func_arg = &opt_show_pixel_formats }, "show pixel format descriptions" },
- { "show_optional_fields", HAS_ARG, { .func_arg = &opt_show_optional_fields }, "show optional fields" },
- { "show_private_data", OPT_BOOL, { &show_private_data }, "show private data" },
- { "private", OPT_BOOL, { &show_private_data }, "same as show_private_data" },
- { "bitexact", OPT_BOOL, {&do_bitexact}, "force bitexact output" },
- { "read_intervals", HAS_ARG, {.func_arg = opt_read_intervals}, "set read intervals", "read_intervals" },
- { "i", HAS_ARG, {.func_arg = opt_input_file_i}, "read specified file", "input_file"},
- { "o", HAS_ARG, {.func_arg = opt_output_file_o}, "write to specified output", "output_file"},
- { "print_filename", HAS_ARG, {.func_arg = opt_print_filename}, "override the printed input filename", "print_file"},
- { "find_stream_info", OPT_BOOL | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
- "read and decode the streams to fill missing information with heuristics" },
- { NULL, },
-};
-
-static inline int check_section_show_entries(int section_id)
-{
- int *id;
- struct section *section = §ions[section_id];
- if (sections[section_id].show_all_entries || sections[section_id].entries_to_show)
- return 1;
- for (id = section->children_ids; *id != -1; id++)
- if (check_section_show_entries(*id))
- return 1;
- return 0;
-}
-
-#define SET_DO_SHOW(id, varname) do { \
- if (check_section_show_entries(SECTION_ID_##id)) \
- do_show_##varname = 1; \
- } while (0)
-
-int main(int argc, char **argv)
-{
- const Writer *w;
- WriterContext *wctx;
- char *buf;
- char *w_name = NULL, *w_args = NULL;
- int ret, input_ret, i;
-
- init_dynload();
-
-#if HAVE_THREADS
- ret = pthread_mutex_init(&log_mutex, NULL);
- if (ret != 0) {
- goto end;
- }
-#endif
- av_log_set_flags(AV_LOG_SKIP_REPEATED);
- register_exit(ffprobe_cleanup);
-
- options = real_options;
- parse_loglevel(argc, argv, options);
- avformat_network_init();
-#if CONFIG_AVDEVICE
- avdevice_register_all();
-#endif
-
- show_banner(argc, argv, options);
- parse_options(NULL, argc, argv, options, opt_input_file);
-
- if (do_show_log)
- av_log_set_callback(log_callback);
-
- /* mark things to show, based on -show_entries */
- SET_DO_SHOW(CHAPTERS, chapters);
- SET_DO_SHOW(ERROR, error);
- SET_DO_SHOW(FORMAT, format);
- SET_DO_SHOW(FRAMES, frames);
- SET_DO_SHOW(LIBRARY_VERSIONS, library_versions);
- SET_DO_SHOW(PACKETS, packets);
- SET_DO_SHOW(PIXEL_FORMATS, pixel_formats);
- SET_DO_SHOW(PIXEL_FORMAT_FLAGS, pixel_format_flags);
- SET_DO_SHOW(PIXEL_FORMAT_COMPONENTS, pixel_format_components);
- SET_DO_SHOW(PROGRAM_VERSION, program_version);
- SET_DO_SHOW(PROGRAMS, programs);
- SET_DO_SHOW(STREAMS, streams);
- SET_DO_SHOW(STREAM_DISPOSITION, stream_disposition);
- SET_DO_SHOW(PROGRAM_STREAM_DISPOSITION, stream_disposition);
-
- SET_DO_SHOW(CHAPTER_TAGS, chapter_tags);
- SET_DO_SHOW(FORMAT_TAGS, format_tags);
- SET_DO_SHOW(FRAME_TAGS, frame_tags);
- SET_DO_SHOW(PROGRAM_TAGS, program_tags);
- SET_DO_SHOW(STREAM_TAGS, stream_tags);
- SET_DO_SHOW(PROGRAM_STREAM_TAGS, stream_tags);
- SET_DO_SHOW(PACKET_TAGS, packet_tags);
-
- if (do_bitexact && (do_show_program_version || do_show_library_versions)) {
- av_log(NULL, AV_LOG_ERROR,
- "-bitexact and -show_program_version or -show_library_versions "
- "options are incompatible\n");
- ret = AVERROR(EINVAL);
- goto end;
- }
-
- writer_register_all();
-
- if (!print_format)
- print_format = av_strdup("default");
- if (!print_format) {
- ret = AVERROR(ENOMEM);
- goto end;
- }
- w_name = av_strtok(print_format, "=", &buf);
- if (!w_name) {
- av_log(NULL, AV_LOG_ERROR,
- "No name specified for the output format\n");
- ret = AVERROR(EINVAL);
- goto end;
- }
- w_args = buf;
-
- if (show_data_hash) {
- if ((ret = av_hash_alloc(&hash, show_data_hash)) < 0) {
- if (ret == AVERROR(EINVAL)) {
- const char *n;
- av_log(NULL, AV_LOG_ERROR,
- "Unknown hash algorithm '%s'\nKnown algorithms:",
- show_data_hash);
- for (i = 0; (n = av_hash_names(i)); i++)
- av_log(NULL, AV_LOG_ERROR, " %s", n);
- av_log(NULL, AV_LOG_ERROR, "\n");
- }
- goto end;
- }
- }
-
- w = writer_get_by_name(w_name);
- if (!w) {
- av_log(NULL, AV_LOG_ERROR, "Unknown output format with name '%s'\n", w_name);
- ret = AVERROR(EINVAL);
- goto end;
- }
-
- if ((ret = writer_open(&wctx, w, w_args,
- sections, FF_ARRAY_ELEMS(sections), output_filename)) >= 0) {
- if (w == &xml_writer)
- wctx->string_validation_utf8_flags |= AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES;
-
- writer_print_section_header(wctx, SECTION_ID_ROOT);
-
- if (do_show_program_version)
- ffprobe_show_program_version(wctx);
- if (do_show_library_versions)
- ffprobe_show_library_versions(wctx);
- if (do_show_pixel_formats)
- ffprobe_show_pixel_formats(wctx);
-
- if (!input_filename &&
- ((do_show_format || do_show_programs || do_show_streams || do_show_chapters || do_show_packets || do_show_error) ||
- (!do_show_program_version && !do_show_library_versions && !do_show_pixel_formats))) {
- show_usage();
- av_log(NULL, AV_LOG_ERROR, "You have to specify one input file.\n");
- av_log(NULL, AV_LOG_ERROR, "Use -h to get full help or, even better, run 'man %s'.\n", program_name);
- ret = AVERROR(EINVAL);
- } else if (input_filename) {
- ret = probe_file(wctx, input_filename, print_input_filename);
- if (ret < 0 && do_show_error)
- show_error(wctx, ret);
- }
-
- input_ret = ret;
-
- writer_print_section_footer(wctx);
- ret = writer_close(&wctx);
- if (ret < 0)
- av_log(NULL, AV_LOG_ERROR, "Writing output failed: %s\n", av_err2str(ret));
-
- ret = FFMIN(ret, input_ret);
- }
-
-end:
- av_freep(&print_format);
- av_freep(&read_intervals);
- av_hash_freep(&hash);
-
- uninit_opts();
- for (i = 0; i < FF_ARRAY_ELEMS(sections); i++)
- av_dict_free(&(sections[i].entries_to_show));
-
- avformat_network_deinit();
-
- return ret < 0;
-}
diff --git a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/acelp_pitch_delay.c b/spaces/colakin/video-generater/public/ffmpeg/libavcodec/acelp_pitch_delay.c
deleted file mode 100644
index 6cf880e4ac136ac653a363903cd29dd9c4dd2d62..0000000000000000000000000000000000000000
--- a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/acelp_pitch_delay.c
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
- * gain code, gain pitch and pitch delay decoding
- *
- * Copyright (c) 2008 Vladimir Voroshilov
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#include "libavutil/common.h"
-#include "libavutil/ffmath.h"
-#include "libavutil/float_dsp.h"
-#include "acelp_pitch_delay.h"
-#include "celp_math.h"
-#include "audiodsp.h"
-
-void ff_acelp_update_past_gain(
- int16_t* quant_energy,
- int gain_corr_factor,
- int log2_ma_pred_order,
- int erasure)
-{
- int i;
- int avg_gain=quant_energy[(1 << log2_ma_pred_order) - 1]; // (5.10)
-
- for(i=(1 << log2_ma_pred_order) - 1; i>0; i--)
- {
- avg_gain += quant_energy[i-1];
- quant_energy[i] = quant_energy[i-1];
- }
-
- if(erasure)
- quant_energy[0] = FFMAX(avg_gain >> log2_ma_pred_order, -10240) - 4096; // -10 and -4 in (5.10)
- else
- quant_energy[0] = (6165 * ((ff_log2_q15(gain_corr_factor) >> 2) - (13 << 13))) >> 13;
-}
-
-int16_t ff_acelp_decode_gain_code(
- AudioDSPContext *adsp,
- int gain_corr_factor,
- const int16_t* fc_v,
- int mr_energy,
- const int16_t* quant_energy,
- const int16_t* ma_prediction_coeff,
- int subframe_size,
- int ma_pred_order)
-{
- int i;
-
- mr_energy <<= 10;
-
- for(i=0; iscalarproduct_int16(fc_v, fc_v, subframe_size, 0))) >> 3) & ~0x3ff);
-
- mr_energy = (5439 * (mr_energy >> 15)) >> 8; // (0.15) = (0.15) * (7.23)
-
- return bidir_sal(
- ((ff_exp2(mr_energy & 0x7fff) + 16) >> 5) * (gain_corr_factor >> 1),
- (mr_energy >> 15) - 25
- );
-#else
- mr_energy = gain_corr_factor * ff_exp10((double)mr_energy / (20 << 23)) /
- sqrt(adsp->scalarproduct_int16(fc_v, fc_v, subframe_size));
- return mr_energy >> 12;
-#endif
-}
-
-float ff_amr_set_fixed_gain(float fixed_gain_factor, float fixed_mean_energy,
- float *prediction_error, float energy_mean,
- const float *pred_table)
-{
- // Equations 66-69:
- // ^g_c = ^gamma_gc * 100.05 (predicted dB + mean dB - dB of fixed vector)
- // Note 10^(0.05 * -10log(average x2)) = 1/sqrt((average x2)).
- float val = fixed_gain_factor *
- ff_exp10(0.05 *
- (avpriv_scalarproduct_float_c(pred_table, prediction_error, 4) +
- energy_mean)) /
- sqrtf(fixed_mean_energy ? fixed_mean_energy : 1.0);
-
- // update quantified prediction error energy history
- memmove(&prediction_error[0], &prediction_error[1],
- 3 * sizeof(prediction_error[0]));
- prediction_error[3] = 20.0 * log10f(fixed_gain_factor);
-
- return val;
-}
-
-void ff_decode_pitch_lag(int *lag_int, int *lag_frac, int pitch_index,
- const int prev_lag_int, const int subframe,
- int third_as_first, int resolution)
-{
- /* Note n * 10923 >> 15 is floor(x/3) for 0 <= n <= 32767 */
- if (subframe == 0 || (subframe == 2 && third_as_first)) {
-
- if (pitch_index < 197)
- pitch_index += 59;
- else
- pitch_index = 3 * pitch_index - 335;
-
- } else {
- if (resolution == 4) {
- int search_range_min = av_clip(prev_lag_int - 5, PITCH_DELAY_MIN,
- PITCH_DELAY_MAX - 9);
-
- // decoding with 4-bit resolution
- if (pitch_index < 4) {
- // integer only precision for [search_range_min, search_range_min+3]
- pitch_index = 3 * (pitch_index + search_range_min) + 1;
- } else if (pitch_index < 12) {
- // 1/3 fractional precision for [search_range_min+3 1/3, search_range_min+5 2/3]
- pitch_index += 3 * search_range_min + 7;
- } else {
- // integer only precision for [search_range_min+6, search_range_min+9]
- pitch_index = 3 * (pitch_index + search_range_min - 6) + 1;
- }
- } else {
- // decoding with 5 or 6 bit resolution, 1/3 fractional precision
- pitch_index--;
-
- if (resolution == 5) {
- pitch_index += 3 * av_clip(prev_lag_int - 10, PITCH_DELAY_MIN,
- PITCH_DELAY_MAX - 19);
- } else
- pitch_index += 3 * av_clip(prev_lag_int - 5, PITCH_DELAY_MIN,
- PITCH_DELAY_MAX - 9);
- }
- }
- *lag_int = pitch_index * 10923 >> 15;
- *lag_frac = pitch_index - 3 * *lag_int - 1;
-}
diff --git a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/frame_thread_encoder.h b/spaces/colakin/video-generater/public/ffmpeg/libavcodec/frame_thread_encoder.h
deleted file mode 100644
index 201cba2a8f107cc5c443ff39b2ca28fd55b280cc..0000000000000000000000000000000000000000
--- a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/frame_thread_encoder.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (c) 2012 Michael Niedermayer
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_FRAME_THREAD_ENCODER_H
-#define AVCODEC_FRAME_THREAD_ENCODER_H
-
-#include "avcodec.h"
-
-/**
- * Initialize frame thread encoder.
- * @note hardware encoders are not supported
- */
-int ff_frame_thread_encoder_init(AVCodecContext *avctx);
-void ff_frame_thread_encoder_free(AVCodecContext *avctx);
-int ff_thread_video_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
- AVFrame *frame, int *got_packet_ptr);
-
-#endif /* AVCODEC_FRAME_THREAD_ENCODER_H */
diff --git a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/h264_mc_template.c b/spaces/colakin/video-generater/public/ffmpeg/libavcodec/h264_mc_template.c
deleted file mode 100644
index d02e2bf580a409aec4a9a88c05c37c2a6cc9e1a3..0000000000000000000000000000000000000000
--- a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/h264_mc_template.c
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
- * H.26L/H.264/AVC/JVT/14496-10/... decoder
- * Copyright (c) 2003 Michael Niedermayer
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#include "h264dec.h"
-
-#undef MCFUNC
-
-#if CHROMA_IDC == 1
-# define MCFUNC(n) FUNC(n ## _420)
-#elif CHROMA_IDC == 2
-# define MCFUNC(n) FUNC(n ## _422)
-#elif CHROMA_IDC == 3
-# define MCFUNC(n) FUNC(n ## _444)
-#endif
-
-#undef mc_part
-#define mc_part MCFUNC(mc_part)
-
-static void mc_part(const H264Context *h, H264SliceContext *sl,
- int n, int square,
- int height, int delta,
- uint8_t *dest_y, uint8_t *dest_cb,
- uint8_t *dest_cr,
- int x_offset, int y_offset,
- const qpel_mc_func *qpix_put,
- h264_chroma_mc_func chroma_put,
- const qpel_mc_func *qpix_avg,
- h264_chroma_mc_func chroma_avg,
- const h264_weight_func *weight_op,
- const h264_biweight_func *weight_avg,
- int list0, int list1)
-{
- if ((sl->pwt.use_weight == 2 && list0 && list1 &&
- (sl->pwt.implicit_weight[sl->ref_cache[0][scan8[n]]][sl->ref_cache[1][scan8[n]]][sl->mb_y & 1] != 32)) ||
- sl->pwt.use_weight == 1)
- mc_part_weighted(h, sl, n, square, height, delta, dest_y, dest_cb, dest_cr,
- x_offset, y_offset, qpix_put, chroma_put,
- weight_op[0], weight_op[1], weight_avg[0],
- weight_avg[1], list0, list1, PIXEL_SHIFT, CHROMA_IDC);
- else
- mc_part_std(h, sl, n, square, height, delta, dest_y, dest_cb, dest_cr,
- x_offset, y_offset, qpix_put, chroma_put, qpix_avg,
- chroma_avg, list0, list1, PIXEL_SHIFT, CHROMA_IDC);
-}
-
-static void MCFUNC(hl_motion)(const H264Context *h, H264SliceContext *sl,
- uint8_t *dest_y,
- uint8_t *dest_cb, uint8_t *dest_cr,
- const qpel_mc_func(*qpix_put)[16],
- const h264_chroma_mc_func(*chroma_put),
- const qpel_mc_func(*qpix_avg)[16],
- const h264_chroma_mc_func(*chroma_avg),
- const h264_weight_func *weight_op,
- const h264_biweight_func *weight_avg)
-{
- const int mb_xy = sl->mb_xy;
- const int mb_type = h->cur_pic.mb_type[mb_xy];
-
- av_assert2(IS_INTER(mb_type));
-
- if (HAVE_THREADS && (h->avctx->active_thread_type & FF_THREAD_FRAME))
- await_references(h, sl);
- if (USES_LIST(mb_type, 0))
- prefetch_motion(h, sl, 0, PIXEL_SHIFT, CHROMA_IDC);
-
- if (IS_16X16(mb_type)) {
- mc_part(h, sl, 0, 1, 16, 0, dest_y, dest_cb, dest_cr, 0, 0,
- qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0],
- weight_op, weight_avg,
- IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
- } else if (IS_16X8(mb_type)) {
- mc_part(h, sl, 0, 0, 8, 8 << PIXEL_SHIFT, dest_y, dest_cb, dest_cr, 0, 0,
- qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
- weight_op, weight_avg,
- IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
- mc_part(h, sl, 8, 0, 8, 8 << PIXEL_SHIFT, dest_y, dest_cb, dest_cr, 0, 4,
- qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
- weight_op, weight_avg,
- IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
- } else if (IS_8X16(mb_type)) {
- mc_part(h, sl, 0, 0, 16, 8 * sl->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0,
- qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
- &weight_op[1], &weight_avg[1],
- IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
- mc_part(h, sl, 4, 0, 16, 8 * sl->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0,
- qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
- &weight_op[1], &weight_avg[1],
- IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
- } else {
- int i;
-
- av_assert2(IS_8X8(mb_type));
-
- for (i = 0; i < 4; i++) {
- const int sub_mb_type = sl->sub_mb_type[i];
- const int n = 4 * i;
- int x_offset = (i & 1) << 2;
- int y_offset = (i & 2) << 1;
-
- if (IS_SUB_8X8(sub_mb_type)) {
- mc_part(h, sl, n, 1, 8, 0, dest_y, dest_cb, dest_cr,
- x_offset, y_offset,
- qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
- &weight_op[1], &weight_avg[1],
- IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
- } else if (IS_SUB_8X4(sub_mb_type)) {
- mc_part(h, sl, n, 0, 4, 4 << PIXEL_SHIFT, dest_y, dest_cb, dest_cr,
- x_offset, y_offset,
- qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
- &weight_op[1], &weight_avg[1],
- IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
- mc_part(h, sl, n + 2, 0, 4, 4 << PIXEL_SHIFT,
- dest_y, dest_cb, dest_cr, x_offset, y_offset + 2,
- qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
- &weight_op[1], &weight_avg[1],
- IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
- } else if (IS_SUB_4X8(sub_mb_type)) {
- mc_part(h, sl, n, 0, 8, 4 * sl->mb_linesize,
- dest_y, dest_cb, dest_cr, x_offset, y_offset,
- qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
- &weight_op[2], &weight_avg[2],
- IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
- mc_part(h, sl, n + 1, 0, 8, 4 * sl->mb_linesize,
- dest_y, dest_cb, dest_cr, x_offset + 2, y_offset,
- qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
- &weight_op[2], &weight_avg[2],
- IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
- } else {
- int j;
- av_assert2(IS_SUB_4X4(sub_mb_type));
- for (j = 0; j < 4; j++) {
- int sub_x_offset = x_offset + 2 * (j & 1);
- int sub_y_offset = y_offset + (j & 2);
- mc_part(h, sl, n + j, 1, 4, 0,
- dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset,
- qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
- &weight_op[2], &weight_avg[2],
- IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
- }
- }
- }
- }
-
- if (USES_LIST(mb_type, 1))
- prefetch_motion(h, sl, 1, PIXEL_SHIFT, CHROMA_IDC);
-}
-
diff --git a/spaces/congsaPfin/Manga-OCR/Ioncube-Php-Encoder-Nulled-Io-TOP.md b/spaces/congsaPfin/Manga-OCR/Ioncube-Php-Encoder-Nulled-Io-TOP.md
deleted file mode 100644
index a51da69ecea8330b28bf0e3aa084df3e1e89b608..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/Ioncube-Php-Encoder-Nulled-Io-TOP.md
+++ /dev/null
@@ -1,96 +0,0 @@
-## ioncube php encoder nulled io
-
-
-
-
-
- 
-
-
-
-
-
-**Download File [https://urlca.com/2txP5o](https://urlca.com/2txP5o)**
-
-
-
-
-
-
-
-
-
-
-
- I'll try to write that for you. Here is a possible title and article:
-
-# How to Use IonCube PHP Encoder to Protect Your PHP Scripts
-
-
-
-If you are a PHP developer, you may want to protect your code from unauthorized use, modification, or theft. One way to do that is by using IonCube PHP Encoder, a powerful tool that can encrypt and license your PHP scripts.
-
-
-
-IonCube PHP Encoder is a software that can encode your PHP files into a format that is unreadable by humans, but still executable by the PHP engine. This way, you can prevent anyone from viewing or changing your source code, and also add features such as expiration dates, domain restrictions, IP restrictions, or MAC address restrictions to control how your scripts can be used.
-
-
-
-IonCube PHP Encoder supports PHP versions from 4.4 to 8.1, and has unique features such as external and dynamic keys encryption, bytecode protection, binary code obfuscation, and runtime compatibility. It also has a command line interface and a graphical user interface for Windows and macOS.
-
-
-
-To use IonCube PHP Encoder, you need to purchase a license from their website[^2^], download the software, and install it on your computer. Then, you can follow these steps to encode your PHP scripts:
-
-
-
-1. Select the files or folders that you want to encode.
-
-2. Choose the encoding options that suit your needs, such as target PHP version, encryption mode, licensing features, etc.
-
-3. Click on the Encode button to start the encoding process.
-
-4. Copy the encoded files to your web server, along with the ionCube Loader file that is required to run them.
-
-
-
-That's it! You have successfully encoded and protected your PHP scripts with IonCube PHP Encoder. You can also use their online service[^2^] if you don't want to install the software on your computer.
-
-
-
-However, be aware that IonCube PHP Encoder is not a free software, and it may not be compatible with some PHP frameworks or extensions. Also, some hackers may try to crack or bypass the encryption using tools such as nulled io[^1^] [^3^] [^4^], which claim to offer cracked versions of IonCube PHP Encoder or other software. These tools are illegal and may contain malware or viruses that can harm your computer or website. Therefore, you should avoid using them and only download IonCube PHP Encoder from their official website[^2^].
-
-
-
-IonCube PHP Encoder is a great solution for protecting your PHP scripts from unauthorized use or modification. It can also help you create secure and flexible licenses for your customers or clients. If you want to learn more about IonCube PHP Encoder, you can visit their website[^2^] or read their documentation[^2^].
-
-I'll try to write that for you. Here are some possible paragraphs:
-
-## Benefits of IonCube PHP Encoder
-
-
-
-Using IonCube PHP Encoder can bring many benefits to PHP developers and website owners. Here are some of the main advantages of using this tool:
-
-
-
-- It can protect your PHP code from unauthorized use, modification, or theft. By encoding your PHP scripts into bytecode, you can prevent anyone from viewing or changing your source code. This can help you protect your intellectual property, your business logic, and your customer data.
-
-- It can improve your PHP performance and reduce server load. By compiling your PHP scripts into bytecode, you can make them run faster and more efficiently on the PHP engine. This can improve your website speed, user experience, and SEO ranking.
-
-- It can create secure and flexible licenses for your PHP products. By using the built-in licensing features of the Pro and Cerberus editions, you can control where and for how long your PHP products can be used. You can also add custom license parameters and messages to suit your needs.
-
-- It can support the latest PHP versions and features. IonCube PHP Encoder supports PHP versions from 4.4 to 8.1, and allows you to use the latest PHP language features in your code. You can also encode your PHP scripts to run on different PHP versions without re-encoding.
-
-- It can integrate with other ionCube products and services. You can use IonCube PHP Encoder with other ionCube products such as Package Foundry, Bundler, and ionCube24. You can also use their online service if you don't want to install the software on your computer.
-
-
-
-These are some of the benefits of using IonCube PHP Encoder to protect your PHP scripts. If you want to try it for yourself, you can download a free trial from their website[^2^] or contact them for more information.
-
- dfd1c89656
-
-
-
-
-
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Download Vlad and Niki 12 Locks APK and Join the Brothers in Their Adventures.md b/spaces/congsaPfin/Manga-OCR/logs/Download Vlad and Niki 12 Locks APK and Join the Brothers in Their Adventures.md
deleted file mode 100644
index cedc8261ff910a5a09cf4a94c89e4dc85512d9a8..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Download Vlad and Niki 12 Locks APK and Join the Brothers in Their Adventures.md
+++ /dev/null
@@ -1,88 +0,0 @@
-
-Vlad and Niki 12 Locks APK: A Fun and Challenging Puzzle Game for Kids
-If you are looking for a fun and challenging puzzle game for your kids, you should check out Vlad and Niki 12 Locks APK. This is an "Escape Room" type of game in which you must find all keys and unlock the target door. The game features the popular YouTube stars Vlad and Niki, who are known for their imaginative and adventurous videos. In this game, they will take you on a journey through different quest-rooms with loads of puzzles and mini-games. The game has amazing plasticine graphics, fun music, and easy controls that make it suitable for kids of all ages. Here is everything you need to know about Vlad and Niki 12 Locks APK.
- What is Vlad and Niki 12 Locks APK?
-A brief introduction to the game and its features
-Vlad and Niki 12 Locks APK is a puzzle game that was released in April 2020 by RUD Present, a developer that specializes in creating games for kids. The game is based on the YouTube series "Vlad & Niki", which features the brothers Vlad and Niki having fun in various scenarios. The game follows a similar theme, as Vlad and Niki want some biscuits, but the jar is shut with 12 locks. To get the biscuits, they have to solve puzzles in different rooms, such as a kitchen, a bathroom, a garage, a spaceship, and more. The game has over 10 million downloads on Google Play Store and has received positive feedback from users.
-vlad and niki 12 locks apk
Download Zip ►►► https://urlca.com/2uOeuL
-A brief introduction to Vlad and Niki, the YouTube stars behind the game
-Vlad and Niki are two brothers from Dubai who have become one of the most popular kidfluencers on YouTube. They started their channel in 2018 and have since gained over 230 million subscribers worldwide across 21 channels in 18 languages. They are known for their creative videos that feature them playing with toys, having adventures, dressing up as superheroes, racing cars, flying planes, going into space, and more. Their videos are produced with a mix of live action, animation, and music to create comedic content for preschoolers. They also have their own merchandise line that includes toys, clothes, books, games, etc.
- How to play Vlad and Niki 12 Locks APK?
-The goal of the game and the basic controls
-The goal of Vlad and Niki 12 Locks APK is to find all the keys and unlock the door that leads to the biscuit jar. The game has simple and intuitive controls that are easy for kids to use. You just have to tap on the screen to interact with objects, drag items to use them, and swipe to move around the room. You can also tap on Vlad and Niki to hear them talk and make funny sounds.
-The different quest-rooms and puzzles in the game
-The game has 12 quest-rooms that are themed after different scenarios that Vlad and Niki have explored in their videos. For example, you can visit a pirate ship, a dinosaur park, a candy land, a circus, a haunted house, and more. Each quest-room has its own unique puzzles that require logic, creativity, and observation skills to solve. Some puzzles involve finding hidden objects, matching colors, shapes, or numbers, solving math problems, cracking codes, etc. You can also use hints if you get stuck on a puzzle.
-The mini-games and rewards in the game
-Besides the puzzles, the game also has mini-games that you can play for fun and rewards. Some of the mini-games include racing cars, flying planes, shooting cannons, playing soccer, etc. You can earn coins by playing these mini-games and use them to buy stickers and decorations for your room. You can also collect stars by completing the quest-rooms and use them to unlock new outfits for Vlad and Niki. The game has a lot of variety and content to keep you entertained for hours.
- Why should you download Vlad and Niki 12 Locks APK?
-The benefits of playing the game for kids
-Vlad and Niki 12 Locks APK is not only a fun game but also an educational one. It can help kids develop their cognitive skills, such as memory, attention, logic, problem-solving, etc. It can also stimulate their imagination and creativity by exposing them to different themes and scenarios. Moreover, it can foster their curiosity and interest in learning new things by presenting them with challenges and rewards. The game is also family-friendly and suitable for kids of all ages.
-The positive reviews and ratings of the game
-Vlad and Niki 12 Locks APK has received a lot of positive reviews and ratings from users who have downloaded and played the game. The game has an average rating of 4.5 out of 5 stars on Google Play Store and has been praised for its graphics, gameplay, sound effects, humor, etc. Some of the comments from users are: - "This game is awesome! My kids love it so much! They watch Vlad and Niki every day and they are so happy to play with them in this game!" - "This is one of the best games I have ever played! It is so fun and challenging! I love the puzzles and the mini-games! The graphics are amazing and the characters are so cute!" - "This game is very educational and entertaining for kids. It helps them learn new things and improve their skills. It is also very funny and colorful. I highly recommend it!"
-The availability and compatibility of the game
-Vlad and Niki 12 Locks APK is available for free download on Google Play Store for Android devices. You can also download it from other sources such as APKPure or APKFab if you want to install it manually on your device. The game requires Android 4.4 or higher to run smoothly and does not take up much space on your device. The game is also compatible with most devices, such as smartphones, tablets, etc.
- Conclusion
-A summary of the main points and a call to action
-Vlad and Niki 12 Locks APK is a fun and challenging puzzle game for kids that features the popular YouTube stars Vlad and Niki. The game has 12 quest-rooms with different themes and puzzles that require logic, creativity, and observation skills to solve. The game also has mini-games that you can play for fun and rewards. The game has amazing plasticine graphics, fun music, easy controls, educational content, positive reviews, free availability, and wide compatibility. If you are looking for a game that will keep your kids entertained and engaged for hours, you should download Vlad and Niki 12 Locks APK today!
-vlad and niki 12 locks game download
-vlad and niki 12 locks mod apk
-vlad and niki 12 locks online
-vlad and niki 12 locks walkthrough
-vlad and niki 12 locks play store
-vlad and niki 12 locks free download
-vlad and niki 12 locks puzzle game
-vlad and niki 12 locks android
-vlad and niki 12 locks latest version
-vlad and niki 12 locks cheats
-vlad and niki 12 locks review
-vlad and niki 12 locks gameplay
-vlad and niki 12 locks for pc
-vlad and niki 12 locks ios
-vlad and niki 12 locks apk pure
-vlad and niki 12 locks apk mirror
-vlad and niki 12 locks apk combo[^1^]
-vlad and niki 12 locks apk mob.org[^2^]
-vlad and niki 12 locks apk uptodown
-vlad and niki 12 locks apk rexdl
-vlad and niki 12 locks apk hack
-vlad and niki 12 locks apk obb
-vlad and niki 12 locks apk data
-vlad and niki 12 locks apk revdl
-vlad and niki 12 locks apk unlimited money
-vlad and niki 12 locks apk no ads
-vlad and niki 12 locks apk full version
-vlad and niki 12 locks apk pro
-vlad and niki 12 locks apk premium
-vlad and niki 12 locks apk cracked
-vlad and niki 12 locks apk mod menu
-vlad and niki 12 locks apk mod download
-vlad and niki 12 locks apk mod free shopping
-vlad and niki 12 locks apk mod unlocked all levels
-vlad and niki 12 locks apk mod unlimited hints
-vlad and niki 12 locks apk mod god mode
-vlad and niki 12 locks apk mod mega mod
-vlad and niki 12 locks apk mod latest update
-vlad and niki 12 locks apk mod offline mode
-vlad and niki 12 locks apk mod no root required
-how to download vlad and niki 12 locks apk
-how to install vlad and niki 12 locks apk
-how to play vlad and niki 12 locks apk
-how to update vlad and niki 12 locks apk
-how to uninstall vlad and niki 12 locks apk
-how to solve puzzles in vlad and niki 12 locks apk
-how to unlock all levels in vlad and niki 12 locks apk
-how to get hints in vlad and niki 12 locks apk
-how to get free coins in vlad and niki 12 locks apk
- FAQs
-Q1: How many levels are there in Vlad and Niki 12 Locks APK?
-A1: There are 12 levels or quest-rooms in Vlad and Niki 12 Locks APK, each with a different theme and puzzle. You can play them in any order you want, but you have to complete all of them to unlock the final door and get the biscuits.
-Q2: How can I download Vlad and Niki 12 Locks APK for free?
-A2: You can download Vlad and Niki 12 Locks APK for free from Google Play Store for Android devices. Just search for the game name and tap on the install button. Alternatively, you can download it from other sources such as APKPure or APKFab if you want to install it manually on your device. Just make sure you download the latest version of the game and enable the unknown sources option on your device settings.
-Q3: Is Vlad and Niki 12 Locks APK safe for kids?
-A3: Yes, Vlad and Niki 12 Locks APK is safe for kids. The game does not contain any violence, gore, profanity, or inappropriate content. The game is also designed for kids of all ages, with easy controls, fun graphics, and educational content. The game is also family-friendly and suitable for playing with parents or siblings.
-Q4: What are some tips and tricks for playing Vlad and Niki 12 Locks APK?
-A4: Some tips and tricks for playing Vlad and Niki 12 Locks APK are: - Explore the room thoroughly and look for clues, objects, or hints that can help you solve the puzzles. - Use the hints if you get stuck on a puzzle. You can get hints by watching ads or using coins that you earn from playing mini-games. - Play the mini-games to earn coins and stars that you can use to buy stickers, decorations, and outfits for your room and characters. - Watch Vlad and Niki's videos on YouTube to get familiar with their personalities, humor, and adventures. This can help you enjoy the game more and relate to the characters better.
-Q5: Where can I find more games like Vlad and Niki 12 Locks APK?
-A5: If you like Vlad and Niki 12 Locks APK, you might also like other games by RUD Present, such as: - Vlad & Niki Supermarket game for Kids: A game where you can go shopping with Vlad and Niki in a supermarket full of surprises. - Vlad & Niki World: A game where you can create your own world with Vlad and Niki using different blocks, items, and characters. - Vlad & Niki Run: A game where you can run, jump, slide, and fly with Vlad and Niki in an endless runner adventure.
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Honkai Star Rail - A Space Fantasy RPG You Cant Miss.md b/spaces/congsaPfin/Manga-OCR/logs/Honkai Star Rail - A Space Fantasy RPG You Cant Miss.md
deleted file mode 100644
index 54e1c3389e26f55a4f648acbc76a3640d78e6c06..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Honkai Star Rail - A Space Fantasy RPG You Cant Miss.md
+++ /dev/null
@@ -1,99 +0,0 @@
-
-How to Download Honkai Impact Star Rail: A Guide for Space Fantasy RPG Fans
- Are you a fan of space fantasy RPGs? Do you love exploring different worlds and fighting against enemies with your unique skills and weapons? If you answered yes to these questions, then you should definitely check out Honkai Impact Star Rail, a brand-new game from the HoYoverse series. In this article, we will tell you what Honkai Impact Star Rail is, why you should download it, and how to download it on your device. Let's get started!
-download honkai impact star rail
Download Zip ———>>> https://urlca.com/2uO5Es
- What is Honkai Impact Star Rail?
- Honkai Impact Star Rail is a spin-off game from the popular Honkai Impact 3rd game, which is set in a post-apocalyptic world where humans fight against the Honkai, a mysterious force that can corrupt anything it touches. Honkai Impact Star Rail takes place in a different timeline, where humans have developed advanced technology and traveled to outer space. However, they still face the threat of the Honkai, which can manifest in different forms across the galaxy.
- A brand-new HoYoverse game
- Honkai Impact Star Rail is part of the HoYoverse series, which includes other games such as Genshin Impact and Tears of Themis. The HoYoverse games share some common elements, such as characters, lore, and aesthetics, but they also have their own unique features and stories. Honkai Impact Star Rail is the first HoYoverse game that focuses on space exploration and combat.
- A space fantasy RPG with stunning graphics and gameplay
- Honkai Impact Star Rail is a space fantasy RPG that lets you experience the beauty and mystery of the cosmos. You can explore different planets and star systems, encounter various creatures and enemies, and collect resources and treasures. You can also engage in thrilling battles using your characters' abilities and weapons, which can be customized according to your preferences. The game boasts stunning graphics that immerse you in the HoYoverse atmosphere.
- A story of traveling across the galaxy with your companions
- Honkai Impact Star Rail has a rich and captivating story that follows you as a special traveler who can travel across the galaxy using a special device called the Star Rail. Along the way, you will meet different characters who will join you on your journey, such as Kiana, Bronya, Mei, and more. You will also uncover the secrets of the HoYoverse and the origin of the Honkai. The game features voice acting and cutscenes that enhance the storytelling.
- Why should you download Honkai Impact Star Rail?
- If you are still not convinced that Honkai Impact Star Rail is a game worth playing, here are some more reasons why you should download it:
- To experience a new game mode: Galactic Roaming
- One of the most unique features of Honkai Impact Star Rail is the Galactic Roaming mode, which allows you to freely explore the galaxy and discover new planets and star systems. You can use your Star Rail to travel between different locations, and use your scanner to detect anomalies and events. You can also interact with other players and NPCs, and participate in quests and missions. Galactic Roaming is a dynamic and open-ended mode that offers endless possibilities and surprises.
-How to download honkai impact star rail on PC
-Honkai impact star rail galactic roaming patch notes
-Honkai impact star rail silver wolf character guide
-Honkai impact star rail astral express gameplay
-Honkai impact star rail honey hunter world database
-Honkai impact star rail best characters tier list
-Honkai impact star rail official website and news
-Honkai impact star rail system requirements and compatibility
-Honkai impact star rail space fantasy RPG review
-Honkai impact star rail trailblazer rewards and top-up
-Honkai impact star rail aeon lore and story
-Honkai impact star rail quantum type characters and skills
-Honkai impact star rail hoyoverse crossover event
-Honkai impact star rail tips and tricks for beginners
-Honkai impact star rail latest update and bug fixes
-Honkai impact star rail community and fan art
-Honkai impact star rail nihility path silver wolf build
-Honkai impact star rail melissa fahn voice actor interview
-Honkai impact star rail soundtrack and theme song
-Honkai impact star rail coupon codes and free gems
-Honkai impact star rail best weapons and equipment
-Honkai impact star rail reroll guide and strategy
-Honkai impact star rail wiki and information source
-Honkai impact star rail discord server and chat
-Honkai impact star rail youtube gameplay videos and channels
-Honkai impact star rail reddit discussion and memes
-Honkai impact star rail twitter news and updates
-Honkai impact star rail facebook page and group
-Honkai impact star rail instagram photos and stories
-Honkai impact star rail tiktok videos and trends
- To collect and customize your characters and weapons
- Honkai Impact Star Rail has a diverse and colorful cast of characters that you can collect and upgrade. Each character has their own personality, backstory, and skills, which can be enhanced by equipping them with different weapons and outfits. You can also customize your weapons by modifying their appearance, performance, and effects. You can mix and match different combinations of characters and weapons to suit your playstyle and preferences.
- To join a community of Trailblazers and explore the HoYoverse
- Honkai Impact Star Rail is not only a single-player game, but also a multiplayer game that lets you connect with other players from around the world. You can join a guild of Trailblazers, which are groups of players who share the same passion for space exploration and adventure. You can chat with your guildmates, cooperate with them in missions, and compete with them in rankings. You can also visit other players' spaceships and see how they decorate them. Honkai Impact Star Rail is a game that fosters a sense of community and friendship among its players.
- How to download Honkai Impact Star Rail?
- Now that you know what Honkai Impact Star Rail is and why you should download it, you might be wondering how to download it on your device. Well, don't worry, because we have got you covered. Here are the steps to download Honkai Impact Star Rail on different platforms:
- For Android users
- If you have an Android device, you can download Honkai Impact Star Rail from the Google Play Store. Here is how:
-
-- Open the Google Play Store app on your device.
-- Search for "Honkai Impact Star Rail" in the search bar.
-- Select the game from the results and tap on "Install".
-- Wait for the game to download and install on your device.
-- Launch the game and enjoy!
-
-Note: Honkai Impact Star Rail requires Android 5.0 or higher, and at least 4 GB of RAM.
- For iOS users
- If you have an iOS device, you can download Honkai Impact Star Rail from the App Store. Here is how:
-
-- Open the App Store app on your device.
-- Search for "Honkai Impact Star Rail" in the search bar.
-- Select the game from the results and tap on "Get".
-- Wait for the game to download and install on your device.
-- Launch the game and enjoy!
-
-Note: Honkai Impact Star Rail requires iOS 10.0 or higher, and at least 4 GB of RAM.
- For PC users
- If you have a PC, you can download Honkai Impact Star Rail from the official website. Here is how:
-
-- Go to https://star-rail.mihoyo.com/en-us/home.
-- Click on "Download Now" on the homepage.
-- Select your region and language from the drop-down menu.
-- Click on "Download" to start downloading the game installer.
-- Run the installer and follow the instructions to install the game on your PC.
-- Launch the game and enjoy!
-
-Note: Honkai Impact Star Rail requires Windows 7 or higher, Intel Core i5 or higher, NVIDIA GeForce GTX 1050 or higher, and at least 8 GB of RAM.
- Conclusion
- Honkai Impact Star Rail is a game that you should not miss if you are a fan of space fantasy RPGs. It is a game that offers you a stunning and immersive experience of exploring the galaxy, collecting and customizing your characters and weapons, and fighting against the Honkai. It is also a game that lets you connect with other players and join a community of Trailblazers. If you want to download Honkai Impact Star Rail, you can follow the steps we have provided for different platforms. We hope you enjoy the game and have fun!
- FAQs
- Here are some frequently asked questions about Honkai Impact Star Rail:
- Q: Is Honkai Impact Star Rail free to play?
-A: Yes, Honkai Impact Star Rail is free to play. However, it also has some optional in-game purchases that can enhance your gameplay.
- Q: Is Honkai Impact Star Rail connected to Honkai Impact 3rd?
-A: Honkai Impact Star Rail is a spin-off game from Honkai Impact 3rd, which means it has some connections to the main game, such as characters and lore. However, it also has its own independent story and timeline, which means you can play it without playing Honkai Impact 3rd first.
- Q: How can I get more characters and weapons in Honkai Impact Star Rail?
-A: You can get more characters and weapons in Honkai Impact Star Rail by participating in events, completing missions, and using the gacha system. The gacha system is a random draw that lets you obtain different items, such as characters, weapons, outfits, and more. You can use different currencies to perform gacha draws, such as crystals, tickets, and coupons.
- Q: How can I play Honkai Impact Star Rail with my friends?
-A: You can play Honkai Impact Star Rail with your friends by joining a guild of Trailblazers, which are groups of players who share the same passion for space exploration and adventure. You can chat with your guildmates, cooperate with them in missions, and compete with them in rankings. You can also visit other players' spaceships and see how they decorate them.
- Q: What are the system requirements for Honkai Impact Star Rail?
-A: The system requirements for Honkai Impact Star Rail vary depending on the platform you are using. For Android users, you need Android 5.0 or higher, and at least 4 GB of RAM. For iOS users, you need iOS 10.0 or higher, and at least 4 GB of RAM. For PC users, you need Windows 7 or higher, Intel Core i5 or higher, NVIDIA GeForce GTX 1050 or higher, and at least 8 GB of RAM.
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/How to Enjoy Gangster Paradise Lofi Song - Free Download and Streaming Options.md b/spaces/congsaPfin/Manga-OCR/logs/How to Enjoy Gangster Paradise Lofi Song - Free Download and Streaming Options.md
deleted file mode 100644
index 7bccd931c7d3836c2e52a324ea59206711e1e73a..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/How to Enjoy Gangster Paradise Lofi Song - Free Download and Streaming Options.md
+++ /dev/null
@@ -1,107 +0,0 @@
-
-Gangster Paradise Lofi Song Download: A Guide for Music Fans
-If you are looking for a relaxing and soothing music genre that can help you unwind, study, or work, you might want to try lo-fi music. Lo-fi stands for low-fidelity, which means that the sound quality is intentionally imperfect and rough. Lo-fi music is influenced by hip hop, jazz, funk, and electro genres, and it often features instrumental, looped, and sampled tracks with ambient noises. Many people find lo-fi music to be mood-boosting, stress-reducing, and focus-enhancing.
-One of the most popular lo-fi songs that you can download or stream online is Gangsta's Paradise by Coolio. This song was originally released in 1995 as a hip hop hit that interpolated Stevie Wonder's song Pastime Paradise from 1976. The song was a social commentary on the struggles of inner-city life and violence, and it was a huge commercial and critical success, winning a Grammy and other awards. However, in recent years, many lo-fi artists have remixed and reinterpreted the song in a new genre, giving it a fresh and mellow vibe.
-gangster paradise lofi song download
Download ❤ https://urlca.com/2uOdDJ
-In this article, we will explore the definition and characteristics of lo-fi music, the origin and meaning of Gangsta's Paradise by Coolio, and the popularity and appeal of its lo-fi remixes. We will also provide some links to download or stream Gangsta's Paradise lo-fi song online. Whether you are a fan of hip hop or lo-fi music, or you are just curious about this musical phenomenon, this article will help you discover more about Gangsta's Paradise lo-fi song download.
- Lo-Fi Music Definition and Characteristics
-Lo-fi music is a type of music that has been made of low quality, embracing imperfections and making them part of the sound. Lo-fi music is characterized by its use of limited instrumentation and production techniques that mimic the sound of older recording technologies. For example, lo-fi music may include incorrect notes, background noise, low hums, tape hiss, distortion, or vinyl crackle.
-Lo-fi music emerged out of DIY (do-it-yourself) music culture in the 1950s as an alternative to high-fidelity (hi-fi) music that was produced in professional studios. Lo-fi music was influenced by various genres such as hip hop, jazz, funk, and electro. Lo-fi music often features instrumental tracks that are looped or sampled and its relevance to contemporary issues. The remixes also showcase the creativity and diversity of lo-fi music, as well as the potential for cross-genre collaborations and innovations.
- Conclusion
-Gangsta's Paradise lo-fi song download is a great choice for music fans who want to enjoy a relaxing and soothing music genre that can help them unwind, study, or work. Lo-fi music is a type of music that has low-fidelity sound quality with intentional imperfections, influenced by hip hop, jazz, funk, and electro genres. Gangsta's Paradise is a song by Coolio that was released in 1995 as a hip hop hit that interpolated Stevie Wonder's song Pastime Paradise. The song was a social commentary on the struggles of inner-city life and violence, and it was a huge commercial and critical success. Many lo-fi artists have remixed and reinterpreted the song in a new genre, giving it a fresh and mellow vibe, while still retaining some elements of the original song. The remixes have gained millions of views and streams on YouTube, Spotify, and other platforms, attracting fans of both hip hop and lo-fi music, as well as new listeners.
-If you want to download or stream Gangsta's Paradise lo-fi song online, you can check out some of these links:
-
-- [Gangsta's Paradise (Lofi Remix) by Lofi Fruits Music]
-- [Gangsta's Paradise (Lofiline Remix) by Lofiline]
-- [Gangsta's Paradise (Chill Fruits Music Remix) by Chill Fruits Music]
-- [Gangsta's Paradise (Future Λ Ready Remix) by Future Λ Ready]
-
-We hope you enjoyed this article and learned more about Gangsta's Paradise lo-fi song download. If you have any questions or comments, feel free to leave them below. Thank you for reading!
- FAQs
-What are some other lo-fi songs that are based on hip hop classics?
-Some other lo-fi songs that are based on hip hop classics are:
-gangster paradise lofi remix mp3 download
-lofi fruits music gangsta's paradise
-gangster paradise lofi version lyrics
-lofiline & mr cat gangsta's paradise
-gangster paradise lofi hip hop beat
-gangsta's paradise lofi fruits music chill fruits music
-gangster paradise lofi spotify
-lofi fruits music gangsta's paradise soundcloud
-gangster paradise lofi cover
-lofiline & mr cat gangsta's paradise shazam
-gangster paradise lofi piano
-gangsta's paradise lofi fruits music chill fruits music youtube
-gangster paradise lofi guitar
-lofi fruits music gangsta's paradise apple music
-gangster paradise lofi instrumental
-gangsta's paradise lofi fruits music chill fruits music lyrics
-gangster paradise lofi tiktok
-lofi fruits music gangsta's paradise free download
-gangster paradise lofi karaoke
-gangsta's paradise lofi fruits music chill fruits music song
-gangster paradise lofi saxophone
-lofi fruits music gangsta's paradise album
-gangster paradise lofi 1 hour
-lofiline & mr cat gangsta's paradise spotify
-gangster paradise lofi flute
-gangsta's paradise lofi fruits music chill fruits music mp3
-gangster paradise lofi ringtone
-lofi fruits music gangsta's paradise genre
-gangster paradise lofi bass boosted
-lofiline & mr cat gangsta's paradise soundcloud
-gangster paradise lofi violin
-gangsta's paradise lofi fruits music chill fruits music video
-gangster paradise lofi trap remix
-lofi fruits music gangsta's paradise release date
-gangster paradise lofi nightcore
-lofiline & mr cat gangsta's paradise lyrics
-gangster paradise lofi jazz remix
-gangsta's paradise lofi fruits music chill fruits music online
-gangster paradise lofi anime amv
-lofi fruits music gangsta's paradise review
-gangster paradise lofi ukulele chords
-lofiline & mr cat gangsta's paradise download
-gangster paradise lofi edm remix
-gangsta's paradise lofi fruits music chill fruits music stream
-gangster paradise lofi meme edit
-lofiline & mr cat - Gangsta's Paradise - Lofi Version (Official Video)
-
-- [Still D.R.E. (Lofi Remix) by Lofi Fruits Music](https://www.youtube.com/watch?v=0FZ9x8lQq9w)
-- [Juicy (Lofi Remix) by Lofiline](https://www.youtube.com/watch?v=Zy0gXnY6dMw)
-- [Changes (Lofi Remix) by Chill Fruits Music](https://www.youtube.com/watch?v=8JtWfYcQOaA)
-- [Lose Yourself (Lofi Remix) by Future Λ Ready](https://www.youtube.com/watch?v=0v7XyWmzT9k)
-
- How can I make my own lo-fi music at home?
-You can make your own lo-fi music at home using some simple tools and techniques. Here are some steps to follow:
-
-- Choose a music software that allows you to create beats and loops. Some examples are FL Studio, Ableton Live, GarageBand, or Audacity.
-- Find some samples or sounds that you want to use for your lo-fi track. You can use your own recordings, or download some from online sources such as Looperman, Splice, or YouTube.
-- Load your samples or sounds into your music software and arrange them into a pattern or sequence. You can use the piano roll or the step sequencer to do this.
-- Add some effects to your track to give it a lo-fi feel. Some common effects are EQ, compression, reverb, delay, distortion, or vinyl simulation.
-- Export your track as an audio file and share it with others online or offline.
-
- What are some benefits of listening to lo-fi music while studying or working?
-Some benefits of listening to lo-fi music while studying or working are:
-
-- Lo-fi music can help you relax and reduce stress by creating a calm and soothing atmosphere.
-- Lo-fi music can help you focus and improve your concentration by blocking out distractions and providing a steady background noise.
-- Lo-fi music can help you boost your mood and motivation by stimulating your brain and releasing dopamine.
-- Lo-fi music can help you enhance your creativity and memory by activating different parts of your brain and stimulating neural connections.
-
- Where can I find more lo-fi music online?
-You can find more lo-fi music online on various platforms and channels that specialize in lo-fi music. Some examples are:
-
-- [YouTube](https://www.youtube.com/): YouTube is one of the most popular and accessible platforms for lo-fi music. You can find many lo-fi music channels, playlists, and live streams on YouTube, such as [ChilledCow](https://www.youtube.com/channel/UCSJ4gkVC6NrvII8umztf0Ow), [Lofi Girl](https://www.youtube.com/channel/UCqGzJ0YixYjxhVHYCQcixEA), [Lofi Fruits Music](https://www.youtube.com/channel/UC8uJaXvHjsq3TCxa_3XsRrw), and [Lofiline](https://www.youtube.com/channel/UC2m4Z7f9w7oJyK1l1t9yQDw).
-- [Spotify](https://www.spotify.com/): Spotify is one of the most popular and versatile platforms for lo-fi music. You can find many lo-fi music artists, albums, playlists, and podcasts on Spotify, such as [Chillhop Music](https://open.spotify.com/artist/6MpczSUmrdLul28bsaMxTe), [Lofi Fruits Music](https://open.spotify.com/artist/5hAMVKYHFyLbGhXteGOWnU), [Lofiline](https://open.spotify.com/artist/6oBm8HB0yfrxUxzD2lmKsQ), and [Lo-Fi Beats](https://open.spotify.com/playlist/37i9dQZF1DWWQRwui0ExPn).
-- [SoundCloud](https://soundcloud.com/): SoundCloud is one of the most popular and creative platforms for lo-fi music. You can find many lo-fi music artists, tracks, groups, and stations on SoundCloud, such as [Chillhop Music](https://soundcloud.com/chillhopdotcom), [Lofi Fruits Music](https://soundcloud.com/lofi-fruits-music), [Lofiline](https://soundcloud.com/lofiline), and [Lo-Fi Hip Hop Radio](https://soundcloud.com/stations/track/chillhopdotcom/chillhop-raw-cuts-2-full-album).
-
- Who are some of the most popular lo-fi artists today?
-Some of the most popular lo-fi artists today are:
-
-- [Jinsang](https://open.spotify.com/artist/5FsfZfRtrtXwNn2JYDeaC5): Jinsang is a lo-fi producer from California who creates smooth and soulful beats with influences from jazz, hip hop, and R&B. Some of his popular songs are [Solitude](https://open.spotify.com/track/4ksgWk9duoHjppnWhRfXsj), [Affection](https://open.spotify.com/track/1rZuEht4txBRmWtZdi2qOL), and [Summer's Day v2](https://open.spotify.com/track/6xGlprv9fmlMj2NhdxNH1C).
-- [Idealism](https://open.spotify.com/artist/6YJ4EgQzDfJnIHRbqIHAdD): Idealism is a lo-fi producer from Germany who creates warm and cozy beats with influences from jazz, hip hop, and ambient. Some of his popular songs are [Controlla](https://open.spotify.com/track/7fRrTyKvE4Skh93v97gtcU), [Hiraeth](https://open.spotify.com/track/3ZffCQKLFLUvYM59XKLbVm), and [Another Perspective](https://open.spotify.com/track/5Sf3GyLEAzJXxZ5mbCPXTu).
-- [Tomppabeats](https://open.spotify.com/artist/0F0MA0ns8oXwGw66B2BSXm): Tomppabeats is a lo-fi producer from Finland who creates nostalgic and dreamy beats with influences from jazz, hip hop, and anime. Some of his popular songs are [U Love](https://open.spotify.com/track/29bIdrNpAToAoznOgNdnGg), [Far Away](https://open.spotify.com/track/7lZauDnRoAC3kmaYae2opv), and [Harbor LP](https://open.spotify.com/album/7x8dCjCr0x6x2lXK HkRnB4).
-
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/How to Install Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK Data on Your Phone.md b/spaces/congsaPfin/Manga-OCR/logs/How to Install Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK Data on Your Phone.md
deleted file mode 100644
index d273cc869d7e90da882f5e46853f06ee1e085330..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/How to Install Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK Data on Your Phone.md
+++ /dev/null
@@ -1,84 +0,0 @@
-
-Download Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data
-If you are a fan of first-person shooter games, you might have heard of Modern Combat 5 Blackout, one of the most popular and thrilling games in this genre. But did you know that you can download a mod version of this game that allows you to play offline and enjoy unlimited money and credits? In this article, we will tell you everything you need to know about Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data, including its features and how to download and install it on your Android device.
-download modern combat 5 blackout mod (offline) v1.3.1a apk + data
Download Zip ✅ https://urlca.com/2uOelN
- Introduction
-What is Modern Combat 5 Blackout?
-Modern Combat 5 Blackout is a first-person shooter game developed by Gameloft and released in 2014. It is the fifth installment in the Modern Combat series, which is inspired by the Call of Duty franchise. The game features a single-player campaign that follows the story of Caydan Phoenix, a former soldier who is involved in a global conspiracy, as well as a multiplayer mode that allows you to compete with other players online in various modes and maps.
- Why download the mod version?
-While Modern Combat 5 Blackout is a free-to-play game, it requires an internet connection to play and has in-app purchases that can enhance your gameplay experience. However, if you want to play offline or enjoy unlimited money and credits without spending real money, you can download the mod version of this game, which has been modified by third-party developers to unlock these features. The mod version also has some other benefits, such as improved performance and bug fixes.
- Features of Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data
-Unlimited money and credits
-One of the main features of Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data is that it gives you unlimited money and credits, which are the two currencies used in the game. You can use them to buy new weapons, armor, skills, and items that can help you in your missions. You can also upgrade your weapons and armor to make them more powerful and durable.
- Offline mode
-Another feature of Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data is that it allows you to play offline, without needing an internet connection. This means that you can enjoy the game anytime and anywhere, without worrying about data usage or connection issues. You can also play the single-player campaign without any interruptions or ads.
- High-quality graphics and sound
-Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data also maintains the high-quality graphics and sound of the original game, which make it one of the best-looking and sounding games on mobile devices. The game features realistic environments, detailed characters, stunning effects, and immersive soundtracks that will make you feel like you are in the middle of a war zone.
- Customizable controls and loadouts
-Another feature of Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data is that it allows you to customize your controls and loadouts according to your preferences and playstyle. You can choose from different control schemes, such as auto-shoot, virtual joystick, or gyroscope, and adjust the sensitivity and layout of the buttons. You can also create your own loadouts by selecting from different classes, weapons, attachments, skills, and items that suit your strategy and tactics.
- Multiplayer and solo modes
-Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data also offers you the option to play either multiplayer or solo modes, depending on your mood and preference. You can join or create online matches with other players around the world in various modes, such as team deathmatch, free-for-all, capture the flag, and more. You can also chat with your teammates and friends using the in-game voice chat feature. Alternatively, you can play solo missions that challenge your skills and reflexes in different scenarios and difficulties.
- How to download and install Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data
-Step 1: Download the APK and data files
-The first step to download and install Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data is to download the APK and data files from a reliable source. You can use the link below to download them directly to your device or computer.
-How to download modern combat 5 blackout offline mod apk + data for free
-Modern combat 5 blackout mod apk + data v1.3.1a offline download link
-Modern combat 5 blackout offline mod apk + data latest version download
-Download modern combat 5 blackout mod apk + data offline mode for android
-Modern combat 5 blackout mod apk + data offline gameplay download
-Modern combat 5 blackout v1.3.1a offline mod apk + data download no root
-Modern combat 5 blackout offline mod apk + data full version download
-Download modern combat 5 blackout mod apk + data offline unlimited money
-Modern combat 5 blackout mod apk + data offline hack download
-Download modern combat 5 blackout mod apk + data offline highly compressed
-Modern combat 5 blackout mod apk + data offline installation guide
-Download modern combat 5 blackout mod apk + data offline without internet
-Modern combat 5 blackout mod apk + data offline features and reviews
-Download modern combat 5 blackout mod apk + data offline update
-Modern combat 5 blackout mod apk + data offline requirements and compatibility
-Download modern combat 5 blackout mod apk + data offline from apkpure
-Modern combat 5 blackout mod apk + data offline best settings and tips
-Download modern combat 5 blackout mod apk + data offline for pc
-Modern combat 5 blackout mod apk + data offline cheats and tricks
-Download modern combat 5 blackout mod apk + data offline from mediafire
-Modern combat 5 blackout mod apk + data offline multiplayer mode download
-Download modern combat 5 blackout mod apk + data offline for ios
-Modern combat 5 blackout mod apk + data offline graphics and sound quality
-Download modern combat 5 blackout mod apk + data offline from google drive
-Modern combat 5 blackout mod apk + data offline missions and challenges download
-Download modern combat 5 blackout mod apk + data offline for windows phone
-Modern combat 5 blackout mod apk + data offline weapons and skins download
-Download modern combat 5 blackout mod apk + data offline from mega.nz
-Modern combat 5 blackout mod apk + data offline bugs and fixes download
-Download modern combat 5 blackout mod apk + data offline for mac
-Modern combat 5 blackout mod apk + data offline maps and locations download
-Download modern combat 5 blackout mod apk + data offline from uptodown
-Modern combat 5 blackout mod apk + data offline ranking and rewards download
-Download modern combat 5 blackout mod apk + data offline for linux
-Modern combat 5 blackout mod apk + data offline customization and options download
- Download Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data
- Step 2: Enable unknown sources on your device
-The next step is to enable unknown sources on your device, which will allow you to install apps from sources other than the Google Play Store. To do this, go to your device's settings, then security, then unknown sources, and toggle it on.
- Step 3: Install the APK file
-After enabling unknown sources, you can install the APK file by tapping on it and following the instructions on the screen. It may take a few minutes for the installation to complete.
- Step 4: Extract and copy the data folder to your device's storage
-The next step is to extract and copy the data folder to your device's storage. To do this, you will need a file manager app that can extract zip files, such as ES File Explorer or ZArchiver. Open the file manager app and locate the zip file that contains the data folder. Extract it and copy the folder named "com.gameloft.android.ANMP.GloftM5HM" to your device's storage, under the path "Android/obb". Make sure that the folder is in the correct location before proceeding.
- Step 5: Launch the game and enjoy
-The final step is to launch the game and enjoy playing Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data on your device. You can access all the features of the mod version without any limitations or restrictions.
- Conclusion
-In conclusion, Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data is a great way to experience one of the best first-person shooter games on mobile devices with enhanced features and performance. You can download and install it easily by following the steps above and enjoy playing offline with unlimited money and credits. If you are looking for a thrilling and action-packed game that will keep you entertained for hours, you should definitely try Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data.
- FAQs
-
-- Is Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data safe to download and install?
-Yes, Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data is safe to download and install as long as you use a trusted source and follow the instructions carefully. However, you should always be careful when downloading apps from unknown sources and scan them for viruses or malware before installing them.
-- Will Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data work on my device?
-Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data should work on most Android devices that have at least 2 GB of RAM and Android 4.0 or higher. However, some devices may not be compatible or may experience some issues due to different specifications or settings. You can check the compatibility of your device by visiting the Google Play Store page of the original game and seeing if it is supported.
-- Can I play Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data with my friends?
-Yes, you can play Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data with your friends online in the multiplayer mode. However, you may not be able to join the same matches or servers as players who are using the original version of the game, as they may have different versions or updates. You can also invite your friends to play with you in the solo mode by using the co-op feature.
-- Will I get banned for using Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data?
-There is a possibility that you may get banned for using Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data, as it is not an official version of the game and may violate the terms and conditions of Gameloft. However, this is unlikely to happen if you play offline and do not use any cheats or hacks that may affect the gameplay or give you an unfair advantage over other players. You should also avoid logging in with your social media accounts or Google Play Games account, as they may detect that you are using a modded version of the game.
-- Can I update Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data?
-No, you cannot update Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data, as it is not connected to the official servers of Gameloft and may not receive any updates or patches from them. If you want to update the game, you will have to download and install a newer version of the mod or switch back to the original version of the game from the Google Play Store.
-
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Stick War Legacy - Control Your Stickmen in a War for Peace and Knowledge.md b/spaces/congsaPfin/Manga-OCR/logs/Stick War Legacy - Control Your Stickmen in a War for Peace and Knowledge.md
deleted file mode 100644
index b4ef4ca3ba004db634693c46b3569dc0ccb8a65b..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Stick War Legacy - Control Your Stickmen in a War for Peace and Knowledge.md
+++ /dev/null
@@ -1,96 +0,0 @@
-
-Stickman War Legacy: A Fun and Challenging Strategy Game
-If you are looking for a game that combines strategy, action, and stick figures, then you should try Stickman War Legacy. This game is a remake of the original Stick War, one of the most popular and highest rated web games of all time. In this game, you can control your army of stickmen in various ways, build units, mine gold, learn new skills, and fight against different enemies. You can also choose from different game modes, such as classic campaign, endless deads, tournament, missions, and more. In this article, we will tell you more about what Stickman War Legacy is, how to play it, and why you should play it.
- What is Stickman War Legacy?
-A remake of the original Stick War game
-Stickman War Legacy is a mobile game published by Max Games Studios in 2016. It is a remake of the original Stick War game that was released in 2009 in Flash. The original game was created by Jason Whitham and Brock White, who also made other stick figure games such as Stick RPG and Territory War. The original game was praised for its gameplay, graphics, sound effects, and humor. It also had a sequel called Stick War 2: Order Empire in 2012.
-stickman war legacy
Download File ➡ https://urlca.com/2uO96G
-A mobile game with multiple modes and features
-Stickman War Legacy is available for iOS and Android devices. It has several modes and features that make it more fun and diverse than the original game. For example, it has a missions mode where new levels are released every Friday. It also has a saga style map with multiple rewards. You can also unlock crowns for each difficulty level: normal, hard, and insane. Moreover, you can unlock skins for all characters and weapons for each class. You can also customize your own avatar with different hats, faces, hair styles, and colors.
-A game with stick figure graphics and animations
-One of the most distinctive aspects of Stickman War Legacy is its graphics and animations. The game uses simple but colorful stick figure drawings to represent the characters, units, buildings, weapons, and environments. The game also has smooth and realistic animations for the movements, attacks, deaths, and blood effects of the stickmen. The game also has sound effects and voice overs that add to the atmosphere and humor of the game.
- How to play Stickman War Legacy?
-Choose your difficulty level and nation
-The game starts with a tutorial that teaches you the basics of the game. You can choose your difficulty level from easy to insane. You can also choose your nation from four options: Order (peaceful and balanced), Chaos (aggressive and chaotic), Elemental (magical and elemental), or 3rd Party (neutral and diverse). Each nation has its own unique units, skills, strengths, and weaknesses.
-Control your army and units in different ways
-You can control your army in formations or play each unit individually. You can use the buttons on the screen to move left or right, attack, defend, mine gold, build units, or cast spells. You can also tap on a unit to select it or drag it to move it around. You can also use gestures to zoom in or out or rotate the camera angle.
-Build units, mine gold, and learn new skills
-You need to build units to
fight against the enemy army. You can build different types of units, such as miners, swordwrath, spearton, archidon, magikill, or giants. Each unit has its own cost, speed, health, damage, and range. You need to mine gold from the gold mines to afford the units. You can also learn new skills from the skill tree, such as faster mining, stronger attacks, or special abilities.
-stickman war legacy game
-stickman war legacy download
-stickman war legacy mod apk
-stickman war legacy cheats
-stickman war legacy hack
-stickman war legacy online
-stickman war legacy skins
-stickman war legacy pc
-stickman war legacy tips
-stickman war legacy strategy
-stickman war legacy walkthrough
-stickman war legacy missions
-stickman war legacy zombies
-stickman war legacy tournament
-stickman war legacy crown of inamorta
-stickman war legacy max games studios
-stickman war legacy play store
-stickman war legacy app store
-stickman war legacy ios
-stickman war legacy android
-stickman war legacy review
-stickman war legacy rating
-stickman war legacy wiki
-stickman war legacy fandom
-stickman war legacy units
-stickman war legacy archers
-stickman war legacy swordsmen
-stickman war legacy mages
-stickman war legacy spearmen
-stickman war legacy giants
-stickman war legacy miner
-stickman war legacy statue
-stickman war legacy gold
-stickman war legacy gems
-stickman war legacy spells
-stickman war legacy shop
-stickman war legacy update
-stickman war legacy new features
-stickman war legacy trailer
-stickman war legacy gameplay
-stickman war legacy graphics
-stickman war legacy sound effects
-stickman war legacy music
-stickman war legacy controls
-stickman war legacy difficulty levels
-stickman war legacy achievements
-stickman war legacy leaderboard
-stickman war legacy multiplayer mode (not yet available)
-stickman war legacy fan art (not yet available)
-Destroy the enemy statue and capture territories
-The main objective of the game is to destroy the enemy statue before they destroy yours. You need to use your strategy and tactics to overcome the enemy defenses and units. You can also capture territories by destroying the towers and flags in each region. Capturing territories will give you more gold and resources. You can also unlock new units and skills by capturing territories.
- Why play Stickman War Legacy?
-It is fun, challenging, and addicting
-Stickman War Legacy is a game that will keep you entertained for hours. It is fun to control your stickmen army and watch them fight in epic battles. It is challenging to face different enemies and scenarios that require different strategies and skills. It is addicting to progress through the game and unlock new units, skills, skins, and modes.
-It has a variety of game types and levels
-Stickman War Legacy has a lot of content and replay value. It has a classic campaign mode where you can play through 40 levels with different nations and difficulties. It also has an endless deads mode where you can survive waves of zombies and skeletons. It also has a tournament mode where you can compete against other players online. It also has a missions mode where you can complete weekly challenges and earn rewards.
-It has a classic strategy war game style
-Stickman War Legacy is a game that pays homage to the classic strategy war games of the past. It has a simple but effective gameplay that requires you to manage your resources, build your army, and plan your attacks. It also has a retro style graphics and sound effects that create a nostalgic atmosphere. It also has a humorous tone that makes fun of the stick figure genre and war games in general.
-It has a loyal fan base and community
-Stickman War Legacy is a game that has a loyal fan base and community. The game has over 100 million downloads on Google Play Store and over 4 million ratings with an average of 4.5 stars. The game also has an active community on social media platforms such as Facebook, YouTube, Instagram, and Discord. The fans share their gameplay videos, tips, tricks, fan art, memes, and feedback with each other.
- Conclusion
-Stickman War Legacy is a fun and challenging strategy game that you should try if you like stick figure games or war games in general. You can control your army of stickmen in various ways, build units, mine gold, learn new skills, and fight against different enemies. You can also choose from different game modes, such as classic campaign, endless deads, tournament, missions, and more. The game also has stick figure graphics and animations, sound effects and voice overs, humor and nostalgia, and a loyal fan base and community. You can download Stickman War Legacy for free on iOS or Android devices and enjoy this amazing game.
- Frequently Asked Questions
-
-- How do I unlock new units and skills?
-You can unlock new units and skills by capturing territories in the campaign mode or by completing missions in the missions mode.
-- How do I change my nation or difficulty level?
-You can change your nation or difficulty level by tapping on the settings icon on the top right corner of the screen.
-- How do I customize my avatar or use skins?
-You can customize your avatar or use skins by tapping on the avatar icon on the top left corner of the screen.
-- How do I play online with other players?
-You can play online with other players by tapping on the tournament icon on the bottom right corner of the screen.
-- How do I contact the developers or give feedback?
-You can contact the developers or give feedback by tapping on the support icon on the bottom left corner of the screen.
-
- : [Stickman War Legacy - Apps on Google Play](https://play.google.com/store/apps/details?id=com.maxgames.stickwarlegacy&hl=en_US&gl=US) 401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Stumble Guys 3.8 A Fast-Paced Knockout Game with Amazing Graphics and Physics.md b/spaces/congsaPfin/Manga-OCR/logs/Stumble Guys 3.8 A Fast-Paced Knockout Game with Amazing Graphics and Physics.md
deleted file mode 100644
index 6f29cce4030f89009f743e94461e982e9ba92242..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Stumble Guys 3.8 A Fast-Paced Knockout Game with Amazing Graphics and Physics.md
+++ /dev/null
@@ -1,99 +0,0 @@
-
-How to Download Stumble Guys 3.8 - The Ultimate Knockout Game
-Do you love playing party games with your friends? Do you enjoy racing through chaotic obstacle courses with up to 32 players online? Do you want to have a lot of fun and laughs while stumbling through different levels until one victor is crowned? If you answered yes to any of these questions, then you should definitely download Stumble Guys 3.8 - the ultimate knockout game!
-What is Stumble Guys 3.8?
-Stumble Guys is a massive multiplayer party knockout game that was released in October 2021 by Scopely. It is inspired by popular TV shows like Wipeout and Takeshi's Castle, where contestants have to overcome various physical challenges and eliminate their rivals. The game is available for both PC and mobile devices, and it supports online and offline modes. You can play with your friends or with strangers from all over the world, and you can customize your character with different outfits and emotes. The game is constantly updated with new maps, obstacles, events, and challenges to keep you entertained and challenged.
-download stumble guys 3.8
Download Zip ⇒ https://urlca.com/2uO6TU
-Why Download Stumble Guys 3.8?
-Stumble Guys 3.8 is the latest version of the game that was released in June 2023. It brings a lot of new features and improvements that make the game even more fun and exciting. Here are some of the reasons why you should download Stumble Guys 3.8:
-New Maps and Obstacles
-Stumble Guys 3.8 introduces six new maps that will test your skills and reflexes in different ways. You will have to navigate through slippery ice, bouncy balls, spinning blades, swinging hammers, flying rockets, and more. Each map has its own theme and style, such as winter wonderland, candy land, medieval castle, space station, pirate ship, and jungle temple. You will never get bored of playing the same map over and over again.
-New Outfits and Emotes
-Stumble Guys 3.8 also adds more than 50 new outfits and emotes that you can use to customize your character and express yourself. You can dress up as a ninja, a cowboy, a superhero, a clown, a robot, a dinosaur, and many more. You can also use different emotes to taunt your opponents, celebrate your victories, or show your frustration. You can unlock these outfits and emotes by playing the game, completing challenges, or buying them with coins or gems.
-New Events and Challenges
-Stumble Guys 3.8 also brings new events and challenges that will keep you engaged and motivated. You can participate in seasonal events that offer special rewards and bonuses, such as Halloween, Christmas, Valentine's Day, Easter, etc. You can also take on daily and weekly challenges that will test your abilities and give you extra coins or gems. You can also join tournaments that will pit you against the best players in the world and give you a chance to win exclusive prizes.
-How to Download Stumble Guys 3.8 for PC?
-If you want to play Stumble Guys 3.8 on your PC, you will need to download it from Steam, which is a digital distribution platform for games. Here are the steps to download Stumble Guys 3.8 for PC:
-
-- Create a Steam account if you don't have one already.
-- Download and install the Steam client on your PC.
-- Launch the Steam client and log in with your account.
-- Search for Stumble Guys in the Steam store or click on this link.
-- Click on the Add to Cart button and proceed to checkout.
-- Pay for the game using your preferred payment method.
-- Wait for the game to download and install on your PC.
-- Launch the game from your Steam library and enjoy!
-
-How to Download Stumble Guys 3.8 for Mobile?
-If you want to play Stumble Guys 3.8 on your mobile device, you will need to download it from Google Play if you have an Android device or from App Store if you have an iOS device. Here are the steps to download Stumble Guys 3.8 for mobile:
-
-- Open Google Play or App Store on your device.
-- Search for Stumble Guys or click on this link for Android or this link for iOS.
-- Tap on the Install button and wait for the game to download and install on your device.
-- Launch the game from your home screen or app drawer and enjoy!
-
- How to Play Stumble Guys 3.8?
- Stumble Guys 3.8 is very easy to play but hard to master. You can play online or offline with friends or strangers in different modes. Here is a brief overview of how to play Stumble Guys 3.8:
- Online Mode
- In online mode, you can join or create online matches with up to 32 players from all over the world. You can choose from different maps and settings, such as round limit, time limit, elimination mode, etc. You can also chat with other players using text or voice messages. The goal is to survive as long as possible and reach the finish line before the others. The last player standing wins the match.
-How to download stumble guys 3.8 on steam
-Stumble guys 3.8 free download for android
-Stumble guys 3.8 update features and tips
-Stumble guys 3.8 web store exclusive deals
-Stumble guys 3.8 gameplay and review
-Download stumble guys 3.8 and join the party
-Stumble guys 3.8 best outfits and emotes
-Stumble guys 3.8 online multiplayer mode
-Stumble guys 3.8 map shortcuts and skips
-Stumble guys 3.8 vs fall guys comparison
-Download stumble guys 3.8 and play with friends
-Stumble guys 3.8 latest news and events
-Stumble guys 3.8 system requirements and compatibility
-Stumble guys 3.8 funniest fails and moments
-Stumble guys 3.8 first-person stumbling guide
-Download stumble guys 3.8 and win the crown
-Stumble guys 3.8 super punch and kick tips
-Stumble guys 3.8 hot wheels hustle tips
-Stumble guys 3.8 wild, wacky, and delicious update
-Stumble guys 3.8 community stream and discord
-Download stumble guys 3.8 for windows 10
-Stumble guys 3.8 how to practice and improve
-Stumble guys 3.8 physics-based havoc and chaos
-Stumble guys 3.8 official card collection
-Stumble guys 3.8 user reviews and ratings
-Download stumble guys 3.8 mod apk unlimited money
-Stumble guys 3.8 how to report a bug or issue
-Stumble guys 3.8 colorful, whacky design
-Stumble guys 3.8 meet prob, expert runs
-Stumble guys 3.8 terms of service and privacy policy
- Party Mode
- In party mode, you can invite or join friends in private matches. You can create a party code and share it with your friends, or enter a party code that your friends have created. You can also use the friend list feature to see who is online and invite them directly. You can customize the match settings, such as map selection, round limit, time limit, etc. You can also chat with your friends using text or voice messages. The goal is to have fun and compete with your friends in a friendly way.
- Offline Mode
- In offline mode, you can play solo or local multiplayer in offline matches. You can choose from different maps and settings, such as round limit, time limit, elimination mode, etc. You can also adjust the difficulty level of the bots, from easy to hard. You can play alone against bots, or with up to three other players on the same device using split-screen mode. The goal is to practice your skills and enjoy the game without internet connection.
- Tips and Tricks for Stumble Guys 3.8
- Stumble Guys 3.8 is a game that requires both luck and skill. You will need to be fast, agile, smart, and sometimes ruthless to win the matches. Here are some tips and tricks that will help you improve your performance and have more fun in Stumble Guys 3.8:
- Map Shortcuts
- Some maps have shortcuts that you can use to gain an advantage over your opponents. These shortcuts can save you time, avoid obstacles, or give you a boost. However, they are also risky and sometimes hard to find. Here is a table showing some map shortcuts and how to use them:
- | Map | Shortcut | How to Use | | --- | --- | --- | | Winter Wonderland | Ice Slide | Jump on the ice slide near the start of the map and slide down to the next checkpoint | | Candy Land | Donut Hole | Jump through the hole in the giant donut near the end of the map and land on the finish line | | Medieval Castle | Catapult | Jump on the catapult near the middle of the map and launch yourself over the wall to the next checkpoint | | Space Station | Rocket Boost | Jump on the rocket near the start of the map and fly over the first obstacle | | Pirate Ship | Cannon | Jump into the cannon near the end of the map and shoot yourself to the finish line | | Jungle Temple | Vine Swing | Grab the vine near the start of the map and swing over the pit to the next checkpoint | Outfit Customization
- You can customize your outfit by changing your head, body, feet, and color. You can unlock more outfit options by playing the game, completing challenges, or buying them with coins or gems. You can also mix and match different outfit parts to create your own unique style. For example, you can wear a ninja head, a superhero body, a clown feet, and a purple color. You can also change your outfit before each match to suit your mood or theme.
- Emote Usage
- You can use emotes to communicate with other players in a fun and expressive way. You can use emotes to taunt your opponents, celebrate your victories, or show your frustration. You can unlock more emotes by playing the game, completing challenges, or buying them with coins or gems. You can also choose which emotes to equip before each match from your emote wheel. You can use emotes at any time during the match by tapping on the emote button on your screen.
- Conclusion
- Stumble Guys 3.8 is a hilarious and addictive party knockout game that you can play with your friends or with strangers online or offline. It is a game that will make you laugh, scream, rage, and cheer as you stumble through different maps and obstacles until one winner is crowned. It is a game that will keep you entertained and challenged with its constant updates and new features. It is a game that you should definitely download and try for yourself.
- So what are you waiting for? Download Stumble Guys 3.8 now and join the ultimate knockout game!
- FAQs
- Here are some frequently asked questions and their answers about Stumble Guys 3.8:
-
-- Is Stumble Guys 3.8 free to play?
-Yes, Stumble Guys 3.8 is free to play on both PC and mobile devices. However, it does have some optional in-app purchases that you can use to buy coins or gems, which can be used to unlock more outfits and emotes. You can also earn coins or gems by playing the game or completing challenges.
-- Is Stumble Guys 3.8 cross-platform?
-Yes, Stumble Guys 3.8 is cross-platform, which means that you can play with other players who are using different devices or platforms. For example, you can play with your friends who are using PC, Android, or iOS devices, as long as you are connected to the same online server or party code.
-- How many players can play Stumble Guys 3.8?
-Stumble Guys 3.8 can support up to 32 players in online mode, which is the maximum number of players that can join or create an online match. In offline mode, you can play solo or with up to three other players on the same device using split-screen mode.
-- How do I report a bug or a problem in Stumble Guys 3.8?
-If you encounter a bug or a problem in Stumble Guys 3.8, you can report it to the developers by using the feedback feature in the game settings. You can also contact them by email at support@scopely.com or by visiting their website at https://www.scopely.com/.
-- How do I get more information about Stumble Guys 3.8?
-If you want to get more information about Stumble Guys 3.8, you can visit their official website at https://www.stumbleguys.com/, where you can find more details about the game, its features, its updates, and its community. You can also follow them on social media platforms, such as Facebook, Twitter, Instagram, YouTube, and Discord, where you can get the latest news, updates, tips, and tricks about the game.
-
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Violet Messenger A Plugin for Libpurple to Support Facebook Chat.md b/spaces/congsaPfin/Manga-OCR/logs/Violet Messenger A Plugin for Libpurple to Support Facebook Chat.md
deleted file mode 100644
index f0a845f06cb42650b9c980820e1bf11d29e5087d..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Violet Messenger A Plugin for Libpurple to Support Facebook Chat.md
+++ /dev/null
@@ -1,95 +0,0 @@
-
-Violet Download Messenger: How to Stay Connected with Your Friends and Family
-Do you want to hang out with your favorite people anytime, anywhere? Do you want to enjoy unlimited text, voice, video calling and group video chat features? Do you want to customize your chats, watch videos together, send and receive money, and chat with businesses? If you answered yes to any of these questions, then you need to download Violet Download Messenger, the free all-in-one communication app that makes it easy and fun to stay close to your friends and family.
-violet download messenger
Download Zip ○ https://urlca.com/2uO9LQ
-What is Violet Download Messenger?
-Violet Download Messenger is a messaging and calling app that lets you connect with your Instagram friends right from Messenger. You can simply search for them by name or username to message or call. You can also use the app to chat with your Facebook friends, even if they're across the world. Violet Download Messenger has a sleek new look that darkens the colors of the chat interface, giving your eyes some rest. You can also record and send voice and video messages when text just won't cut it. You can express yourself with custom stickers, GIFs, and emojis, and use effects and filters to video calls. You can also send files, photos, and videos with no limit, and plan and make things happen with polls and location sharing. You can even send and request money securely and quickly right in the app, or chat with businesses to make reservations, get customer support, find deals and more.
-Why should you use Violet Download Messenger?
-Violet Download Messenger has many benefits that make it a great choice for communication and socializing. Here are some of them:
-Cross-app messaging and calling
-You can connect with your Instagram friends right from Messenger. You don't need to switch between apps or create new accounts. You can also chat with your Facebook friends on the same platform.
-Privacy and safety settings
-You can choose who can reach you, and where your messages are delivered. You can also block or report anyone who makes you feel uncomfortable or unsafe.
-Custom reactions and chat themes
-You can customize your reactions, with lots more emojis to choose from. You can also choose from fun themes and colors, like Tie-Dye or Love, to make your chats more personal.
-How to download violet messenger app for free
-Violet messenger vs Facebook messenger: which one is better?
-Violet messenger features and benefits
-Download violet messenger for iPhone, iPad, and iPod touch
-Violet messenger review: pros and cons
-How to use violet messenger for video calling and group chat
-Violet messenger privacy and security settings
-How to install violet messenger plugin for libpurple
-Violet messenger alternatives and competitors
-How to delete violet messenger account and data
-How to troubleshoot violet messenger issues and errors
-Violet messenger customer service and support
-How to customize violet messenger with themes and stickers
-Violet messenger tips and tricks
-How to invite friends to join violet messenger
-How to backup and restore violet messenger chats
-Violet messenger integration with other apps and services
-How to update violet messenger to the latest version
-Violet messenger user guide and tutorial
-How to make money with violet messenger
-How to use violet messenger for business and marketing
-Violet messenger statistics and trends
-How to access violet messenger on desktop and web
-Violet messenger feedback and suggestions
-How to report violet messenger bugs and problems
-How to block and unblock violet messenger contacts
-Violet messenger notifications and sounds settings
-How to mute and unmute violet messenger conversations
-Violet messenger emojis and GIFs
-How to share files and photos on violet messenger
-How to create and join groups on violet messenger
-Violet messenger voice messages and calls
-How to change your name and profile picture on violet messenger
-Violet messenger status and stories
-How to sync violet messenger across devices
-How to use violet messenger in dark mode
-Violet messenger fun facts and trivia
-How to delete messages and chats on violet messenger
-Violet messenger history and development
-How to use violet messenger offline mode
-Watch together and group video chat
-You can watch videos, tv shows, and movies with your friends over Messenger Video Chat and Rooms when you can't be together. You can capture every moment and reaction in real-time.
-Unlimited free text and phone calls
-You can skip exchanging phone numbers and simply send a message to your friends, even if they're across the world. You can enjoy high-quality voice and text messaging on mobile, tablet, and desktop.
-Dark mode and voice and video messages
-You can give your eyes some rest with a sleek new look that darkens the colors of the chat interface. You can also record and send voice and video messages when text just won't cut it.
-Stickers, GIFs, and emojis
-You can express yourself with custom stickers, GIFs, and emojis. You can use them to show your creative side, your mood, or your humor.File, photo, and video sharing
-
You can send files, photos, and videos with no limit. You can share memories, documents, and more with your friends and family. You can also preview your media before sending and leave a comment if you want.
-Plan and make it happen
-You can create polls to gather opinions from your group. You can also share your location to let people know where you are or where you're going. You can also create events and invite your friends to join.
-Send and request money with no fees
-You can securely send and request money in the app using your debit card or PayPal account. You don't need to pay any fees, and the money will be transferred instantly.
-Chat with businesses
-You can chat with businesses to get things done. You can make reservations, get customer support, find deals, and more. You can also see and respond to messages from your Facebook Page Inbox.
-How to download and install Violet Download Messenger?
-Downloading and installing Violet Download Messenger is easy and fast. Here are the steps to follow:
-
-- Go to the Google Play Store or the App Store on your device.
-- Search for "Violet Download Messenger" or click on one of these links: Android or iOS.
-- Tap on "Install" or "Get" and wait for the app to download.
-- Open the app and sign in with your Facebook account or create a new one.
-- Start chatting with your friends and family!
-
-Conclusion
-Violet Download Messenger is a free all-in-one communication app that lets you stay connected with your friends and family. You can enjoy unlimited text, voice, video calling and group video chat features, as well as customize your chats, watch videos together, send and receive money, and chat with businesses. You can also connect with your Instagram friends right from Messenger, without switching between apps. Violet Download Messenger is easy to download and install on your device, and it has a sleek new look that darkens the colors of the chat interface. If you want to have fun and stay close to your favorite people, download Violet Download Messenger today!
- Frequently Asked Questions
-
-- Q: Is Violet Download Messenger free?
-- A: Yes, Violet Download Messenger is free to download and use. You don't need to pay any fees or subscriptions to enjoy its features.
-- Q: How do I switch between Facebook Messenger and Instagram chats?
-- A: You can switch between Facebook Messenger and Instagram chats by tapping on the profile picture of the person you're chatting with. You'll see a menu that lets you choose which app you want to use.
-- Q: How do I turn on dark mode on Violet Download Messenger?
-- A: You can turn on dark mode on Violet Download Messenger by tapping on your profile picture in the top left corner of the app. Then, tap on "Theme" and choose "Dark".
-- Q: How do I send money on Violet Download Messenger?
-- A: You can send money on Violet Download Messenger by tapping on the "+" icon in the bottom right corner of the chat. Then, tap on "Pay" and choose a contact or enter an amount. You'll need to link your debit card or PayPal account to use this feature.
-- Q: How do I chat with businesses on Violet Download Messenger?
-- A: You can chat with businesses on Violet Download Messenger by tapping on the search icon in the top right corner of the app. Then, type in the name of the business or browse through the categories. You'll see a list of businesses that you can message or call.
-
197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/contluForse/HuggingGPT/assets/3d Album Cs 3.32 Crack REPACK.md b/spaces/contluForse/HuggingGPT/assets/3d Album Cs 3.32 Crack REPACK.md
deleted file mode 100644
index 8eae343f677e3f1177cf912972549aab76e0045b..0000000000000000000000000000000000000000
--- a/spaces/contluForse/HuggingGPT/assets/3d Album Cs 3.32 Crack REPACK.md
+++ /dev/null
@@ -1,12 +0,0 @@
-
-download..3D..Album..Commercial..Suite..v3.29..Portableh33traththarantorrent..for..free,..3D..Album..Commercial..Suite..v3.29..Portableh33traththaran..torrent..download....3d....album....commercial....suite....3.3....portable....Free....Download....3d....album....commercial....suite....2012....3d....album....commercial....suite....Free....Download....3d....album....commercial....suite....Serial.3D-Album...CS...-...awesome...program...for...creating...3D...virtual...albums...based...on...your...images...using...built-in...libraries...of...animation...styles....It...is...a...powerful,...professional.....Results...of...3d...album...commercial...suite...3.33...full:...Free...download...software,...Free...Video...dowloads,...Free...Music...downloads,...Free...Movie...downloads,...Games.Vast....selection....of....software.....Free....Shipping....on....Qualified....Orders..3D....Album....Commercial....Suite....3.28/3D....Album....Commercial....Suite....3.28.daa....-....574.04....MB....3D....Album....Commercial....Suite....3.28/3D....Album....Commercial....Suite....3.28.nfo....-....5.22....KB....3D....Album......portable...3d...album...commercial...suite...3...30...lovely...styles...reupload...Software...-...Free...Download...portable...3d...album...commercial...suite...3...30...lovely...styles...reupload...-...Top...4.....3d..Album..Commercial..Suite..3..33..Free..Full..Version..Download..mediafire..links..free..download,..download..3d..Album..Commercial..Suite..3..3..part1,..3D..ALBUM..COMMERCIAL..SUITE..3..0....Download....3D....Album....Commercial....Suite....Torrent.........3D-Album-Portuguese-Pack.exe....[1.50....MB]....3DAlbumCommercialSuite3.29www.softarchive.net.part1.rar....[99.95....MB].3D-Album...Commercial...Suite...3.33...Portable...Full...version...01....3D...Album...Commercial...Suite...3.33...Portable...Full...version.....3d....album....commercial....suite....3.29....download,....CorelDRAW....Graphics....Suite....X3,....FVD....Suite....2.5.1,....MQuiz....Integer....Addition....-....Adding....Positive....and....Negative....Integers....-....Math....Quiz....1.0.Full...Free...Download...of...3D-Album...Commercial...Suite...3.29...which...is...3D-Album...Commercial...Suite...3.29......650...MB...3D-Album...Commercial...Suite...is...the...complete...digital...solution...for.....MidwayUSA....is....a....privately....held....American....retailer....of....various....hunting....and....outdoor-related....products..3D..Album..Commercial..Suite..3.3..3..Complete..Digital..Imaging..Solution..for..Commercial..Production..Are..you..always..hunting..for..an..exciting..way..to..publish..your....3D..Album..Commercial..Suite..3.33-torrent.zip,..the..sirius..documentary..2013..dvd..download..02e8347b40..taleem..e..balighan..InPixio..Photo..Clip..5.0..Professional.rar.3d..album..commercial..suite..3..Software..-..Free..Download..3d..album..commercial..suite..3..-..Top..4..Download..-..Top4Download.com..offers..free..software..downloads..for..Windows,..Mac....3D-Album....Commercial....Suite....is....the....complete....digital....solution....for....professionals.....It....combines....3D-Albums....unique....and....creative....3D....animated....presentation....templates....with......Vast....selection....of....software.....Free....Shipping....on....Qualified....Orders..Free....download....3d....album....commercial....suite....3....33....Files....at....Software....Informer.....Show,....present,....exhibit,....animate,....publish,....walkthrough,....and....even....design....photo....quiz....games..3D....Album....Commercial....Suite....3.33-torrent.zip.3d..album,..commercial..suite..3.3..download,..free..download..3d..album..commercial..suite..3.3..,..photo..managing..software,..best..graphics..&..photo..editor,..full..version..with..crack....3d....Album....Commercial....Suite....3....33....Free....Full....Version....Download....mediafire....links....free....download,....download....3d....Album....Commercial....Suite....3....3....part1,....3D....ALBUM....COMMERCIAL....SUITE....3....0......3D...Album...commercial...suite...by...galedo....Versions:...3.3...and...3.2..Related....software....to....3d....album....commercial....suite....3.30....free....full....version....download.....Showing....:....1....-....10....from....23.....Adobe....Photoshop....Album....Starter....Edition....3.2....Adobe....Photoshop......Vast...selection...of...software....Free...Shipping...on...Qualified...Orders..Download...3d-album-commercial-suite-3.30-free-full-version-download.3D..Album..Commercial..Suite,..free..download...3D..Album..Commercial..Suite..3.0:..Global..Marketing.3D....Album....Commercial....Suite....version....3.0....+....All....Wedding....Beautiful....Styles........1.2GB.....Easily....create....Hollywood-style....photo....showcases....from....100+....(for....Commercial....Suite....and......[Fshare]...3D...Album...Commercial...Suite...v3.33...-...3D...Album...3.33...full...crack...-...Lm...Album...nh...tuyt...p...cho...bn.Home......Download...3D...Album...Commercial...Suite......Download...3D...Album...Commercial...Suite...latest...version......free...full...verion...of...3D...Album...Commercial...Suite......Download...3D...Album.....3D-Album..Commercial..Suite..3.32....1.8..Gb..3D-Album..Commercial..Suite..3.32....1.8..Gb..The..new..version..of..3D-Album..CS..with..a..complete..set..of..styles..?..is..the..best..program..for....3D..Album..Commercial..Suite..3..32..KeyGen..rar..torrent...Information..about..the..torrent..3D..Album..Commercial..Suite..3..32..KeyGen..rar...Seeders,..leechers..and..torrent..status..is....3D..Album..C
-ommercial..Suite..3.32..Multi/Final....1.78..GB..The..new..version..of..3D-Album..CS..with..a..complete..set..of..styles....is..the..best..program..for..creating..3D....download...3d...Album...commercial...Suitetorrent...for...free,...3d...Album...commercial...Suite...torrent...download,...download...3d...Album...commercial...Suite.Torrent....Contents.....3D....Album....Commercial....Suite....v3.29....Portableh33traththaran....Portable....3D....Album....Commercial....Suite....v3.29.........Portable....3D....Album....Commercial....Suite....v3.29.exe......MidwayUSA...is...a...privately...held...American...retailer...of...various...hunting...and...outdoor-related...products..Full..Free..Download..of..3D..Album..Commercial..Suite..3.30..Final..which..is..3D..Album..Commercial..Suite..3.30..Final....1.8..Gb..The..new..version..of..3D-Album..CS..with..a..complete..set...4c5316f046
-3d Album Cs 3.32 Crack
Download File ⭐ https://ssurll.com/2uzycN
-etabs 9.7.2 portableReadyFor4GB 1.4.raradobe photoshop CS6Extended 13.0.rar password txtGame of Thrones S02E07HDTV.x264-ASAPManual Clinical Surgery S Dasservice manual canonir2520 1m-tek h16106dfg driver win7[PC] Dreams to Reality -ENGHilltop Hoods-Hard Road: Restrung full album zipMavado-GangstaFor Life The Symphony Of David Brooks-RETAiL CD full album zip
-In 1993, Gibson contributed lyrics and featured as a guest vocalist on Yellow Magic Orchestra's Technodon album,[90][91] and wrote lyrics to the track "Dog Star Girl" for Deborah Harry's Debravation.[92]
-Since its debut in 1992, the mystery of Agrippa remained hidden for 20 years. Although many had tried to hack the code and decrypt the program, the uncompiled source code was lost long ago. Alan Liu and his team at "The Agrippa Files"[112] created an extensive website with tools and resources to crack the Agrippa Code. They collaborated with Matthew Kirschenbaum at the Maryland Institute for Technology in the Humanities and the Digital Forensics Lab, and Quinn DuPont, a PhD student of cryptography from the University of Toronto, in calling for the aid of cryptographers to figure out how the program works by creating "Cracking the Agrippa Code: The Challenge",[113] which enlisted participants to solve the intentional scrambling of the poem in exchange for prizes.[114] The code was successfully cracked by Robert Xiao in late July 2012.[113]
-Gibson's work has influenced several popular musicians: references to his fiction appear in the music of Stuart Hamm,[d] Billy Idol,[e] Warren Zevon,[f] Deltron 3030, Straylight Run (whose name is derived from a sequence in Neuromancer)[140] and Sonic Youth. U2's Zooropa album was heavily influenced by Neuromancer,[44] and the band at one point planned to scroll the text of Neuromancer above them on a concert tour, although this did not end up happening. Members of the band did, however, provide background music for the audiobook version of Neuromancer as well as appearing in No Maps for These Territories, a biographical documentary of Gibson.[141] He returned the favour by writing an article about the band's Vertigo Tour for Wired in August 2005.[142] The band Zeromancer take their name from Neuromancer.[143]
-
-Neuromancer was written on a "clockwork typewriter," the very one you may recall glimpsing in Julie Deane's office in Chiba City. This machine, a Hermes 2000 manual portable, dates from somewhere in the 1930s. It's a very tough and elegant piece of work, from the factory of E. PAILLARD & Cie S.A. YVERDON (SUISSE). Cased, it weighs slightly less than the Macintosh SE/30 I now write on, and is finished in a curious green- and-black "crackle" paint-job, perhaps meant to suggest the covers of an accountant's ledger. Its keys are green as well, of celluloid, and the letters and symbols on them are canary yellow. (I once happened to brush the shift-key with the tip of a lit cigarette, dramatically confirming the extreme flammability of this early plastic.) In its day, the Hermes 2000 was one of the best portable writing-machines in the world, and one of the most expensive. This one belonged to my wife's step-grandfather, who had been a journalist of sorts and had used it to compose laudatory essays on the poetry of Robert Burns. I used it first to write undergraduate Eng. lit. papers, then my early attempts at short stories, then Neuromancer, all without so much as ever having touched an actual computer.
aaccfb2cb3
-
-
\ No newline at end of file
diff --git a/spaces/contluForse/HuggingGPT/assets/Avril Lavigne-Lets Go B-Sides Full Album Zip Aereo Dreamweaver Sp.md b/spaces/contluForse/HuggingGPT/assets/Avril Lavigne-Lets Go B-Sides Full Album Zip Aereo Dreamweaver Sp.md
deleted file mode 100644
index e06433c92d75cbcc8a38266d0aaf66a0c83244b8..0000000000000000000000000000000000000000
--- a/spaces/contluForse/HuggingGPT/assets/Avril Lavigne-Lets Go B-Sides Full Album Zip Aereo Dreamweaver Sp.md
+++ /dev/null
@@ -1,6 +0,0 @@
-Avril Lavigne-Lets Go B-Sides Full Album Zip aereo dreamweaver sp
Download Zip 🗸🗸🗸 https://ssurll.com/2uzvGp
-
- aaccfb2cb3
-
-
-
diff --git a/spaces/contluForse/HuggingGPT/assets/BioSolveIT SeeSAR Free Download.md b/spaces/contluForse/HuggingGPT/assets/BioSolveIT SeeSAR Free Download.md
deleted file mode 100644
index dbbf846a112da831c4b85a49e9b3f0c11e855446..0000000000000000000000000000000000000000
--- a/spaces/contluForse/HuggingGPT/assets/BioSolveIT SeeSAR Free Download.md
+++ /dev/null
@@ -1,100 +0,0 @@
-
-BioSolveIT SeeSAR Free Download: A Comprehensive Guide
-
-If you are looking for a software tool that can help you design, optimize, and analyze chemical compounds, you may want to check out BioSolveIT SeeSAR. It is a software solution developed by BioSolveIT GmbH, a leading company in the field of cheminformatics and drug discovery. In this article, we will give you a comprehensive guide on how to get BioSolveIT SeeSAR free download and what are its features and benefits.
-BioSolveIT SeeSAR Free Download
DOWNLOAD ––– https://ssurll.com/2uzyd4
-
-What is BioSolveIT SeeSAR?
-
-BioSolveIT SeeSAR is a software tool for interactive, visual compound prioritization and compound evolution. It is designed for scientists and researchers in the pharmaceutical, biotech, and chemical industries who want to accelerate their drug discovery process and improve their decision making. BioSolveIT SeeSAR allows users to design and optimize chemical compounds based on various criteria, such as binding affinity, selectivity, solubility, toxicity, and synthesis feasibility. It also allows users to analyze chemical structures and properties, such as molecular weight, logP, hydrogen bonds, rotatable bonds, and pharmacophore features. BioSolveIT SeeSAR also supports predictive modeling and simulation of chemical compounds, such as docking, scoring, superposition, pocket exploration, similarity search, and analog search.
-
-BioSolveIT SeeSAR is a user-friendly and intuitive software tool that has a modern and sleek interface. It uses 3D graphics and animations to display chemical compounds and their interactions with targets. It also has a dashboard that shows various information and statistics about the compounds and their optimization progress. Users can easily navigate through the software and perform various tasks with simple mouse clicks and keyboard shortcuts. Users can also collaborate with their team members by sharing their projects and results through email or cloud services.
-
-How to Get BioSolveIT SeeSAR Free Download?
-
-If you want to get BioSolveIT SeeSAR free download, you have two options: you can either request a free trial or apply for an academic license. Both options require you to register on the BioSolveIT website and provide some basic information about yourself and your organization.
-
-
-The free trial option allows you to use BioSolveIT SeeSAR for 30 days without any limitations or obligations. You can download the latest version of the software from the BioSolveIT website and install it on your Windows, Linux, or macOS device. You can also access various resources, such as tutorials, guides, videos, webinars, and support forums to help you get started with the software.
-
-The academic license option allows you to use BioSolveIT SeeSAR for free if you are a student, teacher, or researcher affiliated with an academic institution. You can download the latest version of the software from the BioSolveIT website and install it on your Windows, Linux, or macOS device. You can also access various resources, such as tutorials, guides, videos, webinars, and support forums to help you get started with the software.
-
-What are the Features and Benefits of BioSolveIT SeeSAR?
-
-BioSolveIT SeeSAR is a powerful software tool that has many features and benefits for users who want to design, optimize, and analyze chemical compounds. Some of the main features and benefits are:
-
-
-- BioSolveIT SeeSAR allows users to design and optimize chemical compounds based on various criteria, such as binding affinity, selectivity,
-
BioSolveIT SeeSAR Free Download: How to Install and Use the Software
-
-Once you have downloaded BioSolveIT SeeSAR from the BioSolveIT website, you can easily install and use the software on your device. Here are the steps to install and use BioSolveIT SeeSAR:
-
-
-- Run the downloaded file and follow the instructions on the screen to complete the installation process.
-- Launch BioSolveIT SeeSAR from your desktop or start menu.
-- Enter your email address and password to log in to the software. If you are using a free trial or an academic license, you will also need to enter your activation code that you received from BioSolveIT.
-- Select a project or create a new one. You can also import or export projects from or to other software tools.
-- Add a target protein or a ligand to your project. You can either load them from a file or from a database, such as PDB or PubChem.
-- Use the various features and tools of BioSolveIT SeeSAR to design, optimize, and analyze your compounds. You can also use the dashboard to view various information and statistics about your compounds and their optimization progress.
-- Save your project and share it with your team members or export it to other software tools.
-
-
-If you need any help or guidance on how to use BioSolveIT SeeSAR, you can access various resources, such as tutorials, guides, videos, webinars, and support forums on the BioSolveIT website. You can also contact BioSolveIT GmbH for any technical issues or feedback.
-
-BioSolveIT SeeSAR Free Download: The Pros and Cons of the Software
-
-BioSolveIT SeeSAR is a software tool that has many pros and cons for users who want to design, optimize, and analyze chemical compounds. Here are some of the pros and cons of BioSolveIT SeeSAR:
-
-
-- Pros:
-
- - BioSolveIT SeeSAR is a user-friendly and intuitive software tool that has a modern and sleek interface.
- - BioSolveIT SeeSAR allows users to design and optimize chemical compounds based on various criteria, such as binding affinity, selectivity,
-
BioSolveIT SeeSAR Free Download: The Pricing and Subscription Plans of the Software
-
-BioSolveIT SeeSAR is a software tool that has various pricing and subscription plans for different types of users and organizations. Users can choose the plan that suits their needs and budget. Here are the pricing and subscription plans of BioSolveIT SeeSAR:
-
-
-- Free trial: Users can use BioSolveIT SeeSAR for 30 days without any limitations or obligations. Users can download the latest version of the software from the BioSolveIT website and install it on their Windows, Linux, or macOS device. Users can also access various resources, such as tutorials, guides, videos, webinars, and support forums to help them get started with the software.
-- Academic license: Users who are affiliated with an academic institution can use BioSolveIT SeeSAR for free. Users can download the latest version of the software from the BioSolveIT website and install it on their Windows, Linux, or macOS device. Users can also access various resources, such as tutorials, guides, videos, webinars, and support forums to help them get started with the software.
-- Standard license: Users who want to use BioSolveIT SeeSAR for commercial purposes can purchase a standard license. The standard license costs € 3,000 per year per user and includes all features and updates of the software. Users can also get technical support and customer service from BioSolveIT GmbH.
-- Premium license: Users who want to use BioSolveIT SeeSAR for commercial purposes and also want to customize the software for their specific needs can purchase a premium license. The premium license costs € 5,000 per year per user and includes all features and updates of the software as well as customization options. Users can also get technical support and customer service from BioSolveIT GmbH.
-
-
-BioSolveIT SeeSAR Free Download: The Conclusion
-
-BioSolveIT SeeSAR is a software tool that can help users design, optimize, and analyze chemical compounds. It is a user-friendly and intuitive software tool that has a modern and sleek interface. It allows users to design and optimize chemical compounds based on various criteria, such as binding affinity, selectivity,
-
BioSolveIT SeeSAR Free Download: The Comparison with Other Software Tools
-
-BioSolveIT SeeSAR is a software tool that can be compared with other software tools that offer similar or related features and functions. Some of the software tools that can be compared with BioSolveIT SeeSAR are:
-
-
-- MOE: MOE is a software tool developed by Chemical Computing Group that provides a suite of applications for molecular modeling, drug discovery, protein modeling, cheminformatics, and bioinformatics. MOE has features such as docking, scoring, pharmacophore modeling, QSAR, molecular dynamics, and more.
-- Schrödinger: Schrödinger is a software tool developed by Schrödinger LLC that provides a comprehensive platform for computational chemistry and drug discovery. Schrödinger has features such as ligand-based and structure-based design, virtual screening, lead optimization, ADME/Tox prediction, and more.
-- ChemAxon: ChemAxon is a software tool developed by ChemAxon Ltd that provides a range of solutions for cheminformatics and chemical data management. ChemAxon has features such as structure drawing, structure search, property prediction, library design, and more.
-
-
-Each of these software tools has its own strengths and weaknesses, and users can choose the one that best suits their needs and preferences. However, some of the advantages that BioSolveIT SeeSAR has over these software tools are:
-
-
-- BioSolveIT SeeSAR is more user-friendly and intuitive than these software tools. It has a modern and sleek interface that uses 3D graphics and animations to display chemical compounds and their interactions with targets. It also has a dashboard that shows various information and statistics about the compounds and their optimization progress.
-- BioSolveIT SeeSAR is more interactive and visual than these software tools. It allows users to design and optimize chemical compounds in a visual and interactive way. Users can easily navigate through the software and perform various tasks with simple mouse clicks and keyboard shortcuts.
-- BioSolveIT SeeSAR is more flexible and customizable than these software tools. It allows users to integrate with other software tools to enhance its functionality and usability. Users can also customize the software for their specific needs by contacting BioSolveIT GmbH.
-
-
-BioSolveIT SeeSAR Free Download: The Summary
-
-In conclusion, BioSolveIT SeeSAR is a software tool that can help users design, optimize, and analyze chemical compounds. It is a user-friendly and intuitive software tool that has a modern and sleek interface. It allows users to design and optimize chemical compounds based on various criteria, such as binding affinity, selectivity,
-
BioSolveIT SeeSAR Free Download: The Conclusion
-
-BioSolveIT SeeSAR is a software tool that can help users design, optimize, and analyze chemical compounds. It is a user-friendly and intuitive software tool that has a modern and sleek interface. It allows users to design and optimize chemical compounds based on various criteria, such as binding affinity, selectivity, solubility, toxicity, and synthesis feasibility. It also allows users to analyze chemical structures and properties, such as molecular weight, logP, hydrogen bonds, rotatable bonds, and pharmacophore features. BioSolveIT SeeSAR also supports predictive modeling and simulation of chemical compounds, such as docking, scoring, superposition, pocket exploration, similarity search, and analog search.
-
-BioSolveIT SeeSAR is a software tool that can be integrated with other software tools to enhance its functionality and usability. Users can import or export projects from or to other software tools, such as KNIME, PyMOL, MOE, Schrödinger, ChemAxon, and others. Users can also use various components of BioSolveIT SeeSAR, such as HYDE, FlexX, FlexS, FastGrow, FTrees, SpaceLight, and CoLibri, as standalone tools or as plugins for other software tools.
-
-BioSolveIT SeeSAR is a software tool that has various pricing and subscription plans for different types of users and organizations. Users can choose the plan that suits their needs and budget. Users can either request a free trial or apply for an academic license to use BioSolveIT SeeSAR for free. Users can also purchase a standard license or a premium license to use BioSolveIT SeeSAR for commercial purposes and also customize the software for their specific needs.
-
-BioSolveIT SeeSAR is a software tool that has received positive reviews and testimonials from its customers and users. Users have praised its features and benefits, such as its user-friendliness, interactivity, flexibility, customization options, integration options, and more. Users have also expressed their satisfaction and appreciation of BioSolveIT SeeSAR.
-
-BioSolveIT SeeSAR is a software tool that can be compared with other software tools that offer similar or related features and functions. However, BioSolveIT SeeSAR has some advantages over these software tools, such as its user-friendliness,
3cee63e6c2
-
-
\ No newline at end of file
diff --git a/spaces/contluForse/HuggingGPT/assets/Download Film Jannat 2 Movie 4 Subtitle Indonesia alphabetisch mittele The Story of Love Betrayal and Redemption.md b/spaces/contluForse/HuggingGPT/assets/Download Film Jannat 2 Movie 4 Subtitle Indonesia alphabetisch mittele The Story of Love Betrayal and Redemption.md
deleted file mode 100644
index 31944a01b3fa4e5ad8c22e5a102a8e51987df9ee..0000000000000000000000000000000000000000
--- a/spaces/contluForse/HuggingGPT/assets/Download Film Jannat 2 Movie 4 Subtitle Indonesia alphabetisch mittele The Story of Love Betrayal and Redemption.md
+++ /dev/null
@@ -1,6 +0,0 @@
-Download Film Jannat 2 Movie 4 Subtitle Indonesia alphabetisch mittele
Download > https://ssurll.com/2uzvYZ
-
- aaccfb2cb3
-
-
-
diff --git a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/mmpkg/mmcv/ops/bbox.py b/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/mmpkg/mmcv/ops/bbox.py
deleted file mode 100644
index 0c4d58b6c91f652933974f519acd3403a833e906..0000000000000000000000000000000000000000
--- a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/mmpkg/mmcv/ops/bbox.py
+++ /dev/null
@@ -1,72 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from ..utils import ext_loader
-
-ext_module = ext_loader.load_ext('_ext', ['bbox_overlaps'])
-
-
-def bbox_overlaps(bboxes1, bboxes2, mode='iou', aligned=False, offset=0):
- """Calculate overlap between two set of bboxes.
-
- If ``aligned`` is ``False``, then calculate the ious between each bbox
- of bboxes1 and bboxes2, otherwise the ious between each aligned pair of
- bboxes1 and bboxes2.
-
- Args:
- bboxes1 (Tensor): shape (m, 4) in format or empty.
- bboxes2 (Tensor): shape (n, 4) in format or empty.
- If aligned is ``True``, then m and n must be equal.
- mode (str): "iou" (intersection over union) or iof (intersection over
- foreground).
-
- Returns:
- ious(Tensor): shape (m, n) if aligned == False else shape (m, 1)
-
- Example:
- >>> bboxes1 = torch.FloatTensor([
- >>> [0, 0, 10, 10],
- >>> [10, 10, 20, 20],
- >>> [32, 32, 38, 42],
- >>> ])
- >>> bboxes2 = torch.FloatTensor([
- >>> [0, 0, 10, 20],
- >>> [0, 10, 10, 19],
- >>> [10, 10, 20, 20],
- >>> ])
- >>> bbox_overlaps(bboxes1, bboxes2)
- tensor([[0.5000, 0.0000, 0.0000],
- [0.0000, 0.0000, 1.0000],
- [0.0000, 0.0000, 0.0000]])
-
- Example:
- >>> empty = torch.FloatTensor([])
- >>> nonempty = torch.FloatTensor([
- >>> [0, 0, 10, 9],
- >>> ])
- >>> assert tuple(bbox_overlaps(empty, nonempty).shape) == (0, 1)
- >>> assert tuple(bbox_overlaps(nonempty, empty).shape) == (1, 0)
- >>> assert tuple(bbox_overlaps(empty, empty).shape) == (0, 0)
- """
-
- mode_dict = {'iou': 0, 'iof': 1}
- assert mode in mode_dict.keys()
- mode_flag = mode_dict[mode]
- # Either the boxes are empty or the length of boxes' last dimension is 4
- assert (bboxes1.size(-1) == 4 or bboxes1.size(0) == 0)
- assert (bboxes2.size(-1) == 4 or bboxes2.size(0) == 0)
- assert offset == 1 or offset == 0
-
- rows = bboxes1.size(0)
- cols = bboxes2.size(0)
- if aligned:
- assert rows == cols
-
- if rows * cols == 0:
- return bboxes1.new(rows, 1) if aligned else bboxes1.new(rows, cols)
-
- if aligned:
- ious = bboxes1.new_zeros(rows)
- else:
- ious = bboxes1.new_zeros((rows, cols))
- ext_module.bbox_overlaps(
- bboxes1, bboxes2, ious, mode=mode_flag, aligned=aligned, offset=offset)
- return ious
diff --git a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/mmpkg/mmcv/ops/pixel_group.py b/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/mmpkg/mmcv/ops/pixel_group.py
deleted file mode 100644
index 2143c75f835a467c802fc3c37ecd3ac0f85bcda4..0000000000000000000000000000000000000000
--- a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/mmpkg/mmcv/ops/pixel_group.py
+++ /dev/null
@@ -1,75 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import numpy as np
-import torch
-
-from ..utils import ext_loader
-
-ext_module = ext_loader.load_ext('_ext', ['pixel_group'])
-
-
-def pixel_group(score, mask, embedding, kernel_label, kernel_contour,
- kernel_region_num, distance_threshold):
- """Group pixels into text instances, which is widely used text detection
- methods.
-
- Arguments:
- score (np.array or Tensor): The foreground score with size hxw.
- mask (np.array or Tensor): The foreground mask with size hxw.
- embedding (np.array or Tensor): The embedding with size hxwxc to
- distinguish instances.
- kernel_label (np.array or Tensor): The instance kernel index with
- size hxw.
- kernel_contour (np.array or Tensor): The kernel contour with size hxw.
- kernel_region_num (int): The instance kernel region number.
- distance_threshold (float): The embedding distance threshold between
- kernel and pixel in one instance.
-
- Returns:
- pixel_assignment (List[List[float]]): The instance coordinate list.
- Each element consists of averaged confidence, pixel number, and
- coordinates (x_i, y_i for all pixels) in order.
- """
- assert isinstance(score, (torch.Tensor, np.ndarray))
- assert isinstance(mask, (torch.Tensor, np.ndarray))
- assert isinstance(embedding, (torch.Tensor, np.ndarray))
- assert isinstance(kernel_label, (torch.Tensor, np.ndarray))
- assert isinstance(kernel_contour, (torch.Tensor, np.ndarray))
- assert isinstance(kernel_region_num, int)
- assert isinstance(distance_threshold, float)
-
- if isinstance(score, np.ndarray):
- score = torch.from_numpy(score)
- if isinstance(mask, np.ndarray):
- mask = torch.from_numpy(mask)
- if isinstance(embedding, np.ndarray):
- embedding = torch.from_numpy(embedding)
- if isinstance(kernel_label, np.ndarray):
- kernel_label = torch.from_numpy(kernel_label)
- if isinstance(kernel_contour, np.ndarray):
- kernel_contour = torch.from_numpy(kernel_contour)
-
- if torch.__version__ == 'parrots':
- label = ext_module.pixel_group(
- score,
- mask,
- embedding,
- kernel_label,
- kernel_contour,
- kernel_region_num=kernel_region_num,
- distance_threshold=distance_threshold)
- label = label.tolist()
- label = label[0]
- list_index = kernel_region_num
- pixel_assignment = []
- for x in range(kernel_region_num):
- pixel_assignment.append(
- np.array(
- label[list_index:list_index + int(label[x])],
- dtype=np.float))
- list_index = list_index + int(label[x])
- else:
- pixel_assignment = ext_module.pixel_group(score, mask, embedding,
- kernel_label, kernel_contour,
- kernel_region_num,
- distance_threshold)
- return pixel_assignment
diff --git a/spaces/daddyjin/TalkingFaceGeneration/Demo_TFR_Pirenderer/src/pirenderer/util/trainer.py b/spaces/daddyjin/TalkingFaceGeneration/Demo_TFR_Pirenderer/src/pirenderer/util/trainer.py
deleted file mode 100644
index 420da43f4fac6566aeb0da9df4f7e09cbf40428d..0000000000000000000000000000000000000000
--- a/spaces/daddyjin/TalkingFaceGeneration/Demo_TFR_Pirenderer/src/pirenderer/util/trainer.py
+++ /dev/null
@@ -1,136 +0,0 @@
-import random
-import importlib
-import numpy as np
-
-import torch
-import torch.nn as nn
-from torch.optim import Adam, lr_scheduler
-
-from util.distributed import master_only_print as print
-from util.init_weight import weights_init
-
-def accumulate(model1, model2, decay=0.999):
- par1 = dict(model1.named_parameters())
- par2 = dict(model2.named_parameters())
-
- for k in par1.keys():
- par1[k].data.mul_(decay).add_(par2[k].data, alpha=1 - decay)
-
-def set_random_seed(seed):
- r"""Set random seeds for everything.
-
- Args:
- seed (int): Random seed.
- by_rank (bool):
- """
- random.seed(seed)
- np.random.seed(seed)
- torch.manual_seed(seed)
- torch.cuda.manual_seed(seed)
- torch.cuda.manual_seed_all(seed)
-
-
-
-def get_trainer(opt, net_G, net_G_ema, opt_G, sch_G, train_dataset):
- module, trainer_name = opt.trainer.type.split('::')
-
- trainer_lib = importlib.import_module(module)
- trainer_class = getattr(trainer_lib, trainer_name)
- trainer = trainer_class(opt, net_G, net_G_ema, opt_G, sch_G, train_dataset)
- return trainer
-
-def get_model_optimizer_and_scheduler(opt):
- gen_module, gen_network_name = opt.gen.type.split('::')
- lib = importlib.import_module(gen_module)
- network = getattr(lib, gen_network_name)
- net_G = network(**opt.gen.param).to(opt.device)
- init_bias = getattr(opt.trainer.init, 'bias', None)
- net_G.apply(weights_init(
- opt.trainer.init.type, opt.trainer.init.gain, init_bias))
-
- net_G_ema = network(**opt.gen.param).to(opt.device)
- net_G_ema.eval()
- accumulate(net_G_ema, net_G, 0)
- print('net [{}] parameter count: {:,}'.format(
- 'net_G', _calculate_model_size(net_G)))
- print('Initialize net_G weights using '
- 'type: {} gain: {}'.format(opt.trainer.init.type,
- opt.trainer.init.gain))
-
-
- opt_G = get_optimizer(opt.gen_optimizer, net_G)
-
- if opt.distributed:
- net_G = nn.parallel.DistributedDataParallel(
- net_G,
- device_ids=[opt.local_rank],
- output_device=opt.local_rank,
- broadcast_buffers=False,
- find_unused_parameters=True,
- )
-
- # Scheduler
- sch_G = get_scheduler(opt.gen_optimizer, opt_G)
- return net_G, net_G_ema, opt_G, sch_G
-
-
-def _calculate_model_size(model):
- r"""Calculate number of parameters in a PyTorch network.
-
- Args:
- model (obj): PyTorch network.
-
- Returns:
- (int): Number of parameters.
- """
- return sum(p.numel() for p in model.parameters() if p.requires_grad)
-
-
-def get_scheduler(opt_opt, opt):
- """Return the scheduler object.
-
- Args:
- opt_opt (obj): Config for the specific optimization module (gen/dis).
- opt (obj): PyTorch optimizer object.
-
- Returns:
- (obj): Scheduler
- """
- if opt_opt.lr_policy.type == 'step':
- scheduler = lr_scheduler.StepLR(
- opt,
- step_size=opt_opt.lr_policy.step_size,
- gamma=opt_opt.lr_policy.gamma)
- elif opt_opt.lr_policy.type == 'constant':
- scheduler = lr_scheduler.LambdaLR(opt, lambda x: 1)
- else:
- return NotImplementedError('Learning rate policy {} not implemented.'.
- format(opt_opt.lr_policy.type))
- return scheduler
-
-
-def get_optimizer(opt_opt, net):
- return get_optimizer_for_params(opt_opt, net.parameters())
-
-
-def get_optimizer_for_params(opt_opt, params):
- r"""Return the scheduler object.
-
- Args:
- opt_opt (obj): Config for the specific optimization module (gen/dis).
- params (obj): Parameters to be trained by the parameters.
-
- Returns:
- (obj): Optimizer
- """
- # We will use fuse optimizers by default.
- if opt_opt.type == 'adam':
- opt = Adam(params,
- lr=opt_opt.lr,
- betas=(opt_opt.adam_beta1, opt_opt.adam_beta2))
- else:
- raise NotImplementedError(
- 'Optimizer {} is not yet implemented.'.format(opt_opt.type))
- return opt
-
-
diff --git a/spaces/danterivers/music-generation-samples/audiocraft/modules/conv.py b/spaces/danterivers/music-generation-samples/audiocraft/modules/conv.py
deleted file mode 100644
index 972938ab84712eb06e1b10cea25444eee51d6637..0000000000000000000000000000000000000000
--- a/spaces/danterivers/music-generation-samples/audiocraft/modules/conv.py
+++ /dev/null
@@ -1,245 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-import math
-import typing as tp
-import warnings
-
-import torch
-from torch import nn
-from torch.nn import functional as F
-from torch.nn.utils import spectral_norm, weight_norm
-
-
-CONV_NORMALIZATIONS = frozenset(['none', 'weight_norm', 'spectral_norm',
- 'time_group_norm'])
-
-
-def apply_parametrization_norm(module: nn.Module, norm: str = 'none'):
- assert norm in CONV_NORMALIZATIONS
- if norm == 'weight_norm':
- return weight_norm(module)
- elif norm == 'spectral_norm':
- return spectral_norm(module)
- else:
- # We already check was in CONV_NORMALIZATION, so any other choice
- # doesn't need reparametrization.
- return module
-
-
-def get_norm_module(module: nn.Module, causal: bool = False, norm: str = 'none', **norm_kwargs):
- """Return the proper normalization module. If causal is True, this will ensure the returned
- module is causal, or return an error if the normalization doesn't support causal evaluation.
- """
- assert norm in CONV_NORMALIZATIONS
- if norm == 'time_group_norm':
- if causal:
- raise ValueError("GroupNorm doesn't support causal evaluation.")
- assert isinstance(module, nn.modules.conv._ConvNd)
- return nn.GroupNorm(1, module.out_channels, **norm_kwargs)
- else:
- return nn.Identity()
-
-
-def get_extra_padding_for_conv1d(x: torch.Tensor, kernel_size: int, stride: int,
- padding_total: int = 0) -> int:
- """See `pad_for_conv1d`.
- """
- length = x.shape[-1]
- n_frames = (length - kernel_size + padding_total) / stride + 1
- ideal_length = (math.ceil(n_frames) - 1) * stride + (kernel_size - padding_total)
- return ideal_length - length
-
-
-def pad_for_conv1d(x: torch.Tensor, kernel_size: int, stride: int, padding_total: int = 0):
- """Pad for a convolution to make sure that the last window is full.
- Extra padding is added at the end. This is required to ensure that we can rebuild
- an output of the same length, as otherwise, even with padding, some time steps
- might get removed.
- For instance, with total padding = 4, kernel size = 4, stride = 2:
- 0 0 1 2 3 4 5 0 0 # (0s are padding)
- 1 2 3 # (output frames of a convolution, last 0 is never used)
- 0 0 1 2 3 4 5 0 # (output of tr. conv., but pos. 5 is going to get removed as padding)
- 1 2 3 4 # once you removed padding, we are missing one time step !
- """
- extra_padding = get_extra_padding_for_conv1d(x, kernel_size, stride, padding_total)
- return F.pad(x, (0, extra_padding))
-
-
-def pad1d(x: torch.Tensor, paddings: tp.Tuple[int, int], mode: str = 'constant', value: float = 0.):
- """Tiny wrapper around F.pad, just to allow for reflect padding on small input.
- If this is the case, we insert extra 0 padding to the right before the reflection happen.
- """
- length = x.shape[-1]
- padding_left, padding_right = paddings
- assert padding_left >= 0 and padding_right >= 0, (padding_left, padding_right)
- if mode == 'reflect':
- max_pad = max(padding_left, padding_right)
- extra_pad = 0
- if length <= max_pad:
- extra_pad = max_pad - length + 1
- x = F.pad(x, (0, extra_pad))
- padded = F.pad(x, paddings, mode, value)
- end = padded.shape[-1] - extra_pad
- return padded[..., :end]
- else:
- return F.pad(x, paddings, mode, value)
-
-
-def unpad1d(x: torch.Tensor, paddings: tp.Tuple[int, int]):
- """Remove padding from x, handling properly zero padding. Only for 1d!
- """
- padding_left, padding_right = paddings
- assert padding_left >= 0 and padding_right >= 0, (padding_left, padding_right)
- assert (padding_left + padding_right) <= x.shape[-1]
- end = x.shape[-1] - padding_right
- return x[..., padding_left: end]
-
-
-class NormConv1d(nn.Module):
- """Wrapper around Conv1d and normalization applied to this conv
- to provide a uniform interface across normalization approaches.
- """
- def __init__(self, *args, causal: bool = False, norm: str = 'none',
- norm_kwargs: tp.Dict[str, tp.Any] = {}, **kwargs):
- super().__init__()
- self.conv = apply_parametrization_norm(nn.Conv1d(*args, **kwargs), norm)
- self.norm = get_norm_module(self.conv, causal, norm, **norm_kwargs)
- self.norm_type = norm
-
- def forward(self, x):
- x = self.conv(x)
- x = self.norm(x)
- return x
-
-
-class NormConv2d(nn.Module):
- """Wrapper around Conv2d and normalization applied to this conv
- to provide a uniform interface across normalization approaches.
- """
- def __init__(self, *args, norm: str = 'none', norm_kwargs: tp.Dict[str, tp.Any] = {}, **kwargs):
- super().__init__()
- self.conv = apply_parametrization_norm(nn.Conv2d(*args, **kwargs), norm)
- self.norm = get_norm_module(self.conv, causal=False, norm=norm, **norm_kwargs)
- self.norm_type = norm
-
- def forward(self, x):
- x = self.conv(x)
- x = self.norm(x)
- return x
-
-
-class NormConvTranspose1d(nn.Module):
- """Wrapper around ConvTranspose1d and normalization applied to this conv
- to provide a uniform interface across normalization approaches.
- """
- def __init__(self, *args, causal: bool = False, norm: str = 'none',
- norm_kwargs: tp.Dict[str, tp.Any] = {}, **kwargs):
- super().__init__()
- self.convtr = apply_parametrization_norm(nn.ConvTranspose1d(*args, **kwargs), norm)
- self.norm = get_norm_module(self.convtr, causal, norm, **norm_kwargs)
- self.norm_type = norm
-
- def forward(self, x):
- x = self.convtr(x)
- x = self.norm(x)
- return x
-
-
-class NormConvTranspose2d(nn.Module):
- """Wrapper around ConvTranspose2d and normalization applied to this conv
- to provide a uniform interface across normalization approaches.
- """
- def __init__(self, *args, norm: str = 'none', norm_kwargs: tp.Dict[str, tp.Any] = {}, **kwargs):
- super().__init__()
- self.convtr = apply_parametrization_norm(nn.ConvTranspose2d(*args, **kwargs), norm)
- self.norm = get_norm_module(self.convtr, causal=False, norm=norm, **norm_kwargs)
-
- def forward(self, x):
- x = self.convtr(x)
- x = self.norm(x)
- return x
-
-
-class StreamableConv1d(nn.Module):
- """Conv1d with some builtin handling of asymmetric or causal padding
- and normalization.
- """
- def __init__(self, in_channels: int, out_channels: int,
- kernel_size: int, stride: int = 1, dilation: int = 1,
- groups: int = 1, bias: bool = True, causal: bool = False,
- norm: str = 'none', norm_kwargs: tp.Dict[str, tp.Any] = {},
- pad_mode: str = 'reflect'):
- super().__init__()
- # warn user on unusual setup between dilation and stride
- if stride > 1 and dilation > 1:
- warnings.warn('StreamableConv1d has been initialized with stride > 1 and dilation > 1'
- f' (kernel_size={kernel_size} stride={stride}, dilation={dilation}).')
- self.conv = NormConv1d(in_channels, out_channels, kernel_size, stride,
- dilation=dilation, groups=groups, bias=bias, causal=causal,
- norm=norm, norm_kwargs=norm_kwargs)
- self.causal = causal
- self.pad_mode = pad_mode
-
- def forward(self, x):
- B, C, T = x.shape
- kernel_size = self.conv.conv.kernel_size[0]
- stride = self.conv.conv.stride[0]
- dilation = self.conv.conv.dilation[0]
- kernel_size = (kernel_size - 1) * dilation + 1 # effective kernel size with dilations
- padding_total = kernel_size - stride
- extra_padding = get_extra_padding_for_conv1d(x, kernel_size, stride, padding_total)
- if self.causal:
- # Left padding for causal
- x = pad1d(x, (padding_total, extra_padding), mode=self.pad_mode)
- else:
- # Asymmetric padding required for odd strides
- padding_right = padding_total // 2
- padding_left = padding_total - padding_right
- x = pad1d(x, (padding_left, padding_right + extra_padding), mode=self.pad_mode)
- return self.conv(x)
-
-
-class StreamableConvTranspose1d(nn.Module):
- """ConvTranspose1d with some builtin handling of asymmetric or causal padding
- and normalization.
- """
- def __init__(self, in_channels: int, out_channels: int,
- kernel_size: int, stride: int = 1, causal: bool = False,
- norm: str = 'none', trim_right_ratio: float = 1.,
- norm_kwargs: tp.Dict[str, tp.Any] = {}):
- super().__init__()
- self.convtr = NormConvTranspose1d(in_channels, out_channels, kernel_size, stride,
- causal=causal, norm=norm, norm_kwargs=norm_kwargs)
- self.causal = causal
- self.trim_right_ratio = trim_right_ratio
- assert self.causal or self.trim_right_ratio == 1., \
- "`trim_right_ratio` != 1.0 only makes sense for causal convolutions"
- assert self.trim_right_ratio >= 0. and self.trim_right_ratio <= 1.
-
- def forward(self, x):
- kernel_size = self.convtr.convtr.kernel_size[0]
- stride = self.convtr.convtr.stride[0]
- padding_total = kernel_size - stride
-
- y = self.convtr(x)
-
- # We will only trim fixed padding. Extra padding from `pad_for_conv1d` would be
- # removed at the very end, when keeping only the right length for the output,
- # as removing it here would require also passing the length at the matching layer
- # in the encoder.
- if self.causal:
- # Trim the padding on the right according to the specified ratio
- # if trim_right_ratio = 1.0, trim everything from right
- padding_right = math.ceil(padding_total * self.trim_right_ratio)
- padding_left = padding_total - padding_right
- y = unpad1d(y, (padding_left, padding_right))
- else:
- # Asymmetric padding required for odd strides
- padding_right = padding_total // 2
- padding_left = padding_total - padding_right
- y = unpad1d(y, (padding_left, padding_right))
- return y
diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/PIL/XbmImagePlugin.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/PIL/XbmImagePlugin.py
deleted file mode 100644
index 3c12564c963d8b6342fa6ef1d7fc1892af30ffff..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/PIL/XbmImagePlugin.py
+++ /dev/null
@@ -1,94 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# XBM File handling
-#
-# History:
-# 1995-09-08 fl Created
-# 1996-11-01 fl Added save support
-# 1997-07-07 fl Made header parser more tolerant
-# 1997-07-22 fl Fixed yet another parser bug
-# 2001-02-17 fl Use 're' instead of 'regex' (Python 2.1) (0.4)
-# 2001-05-13 fl Added hotspot handling (based on code from Bernhard Herzog)
-# 2004-02-24 fl Allow some whitespace before first #define
-#
-# Copyright (c) 1997-2004 by Secret Labs AB
-# Copyright (c) 1996-1997 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-import re
-
-from . import Image, ImageFile
-
-# XBM header
-xbm_head = re.compile(
- rb"\s*#define[ \t]+.*_width[ \t]+(?P[0-9]+)[\r\n]+"
- b"#define[ \t]+.*_height[ \t]+(?P[0-9]+)[\r\n]+"
- b"(?P"
- b"#define[ \t]+[^_]*_x_hot[ \t]+(?P[0-9]+)[\r\n]+"
- b"#define[ \t]+[^_]*_y_hot[ \t]+(?P[0-9]+)[\r\n]+"
- b")?"
- rb"[\000-\377]*_bits\[]"
-)
-
-
-def _accept(prefix):
- return prefix.lstrip()[:7] == b"#define"
-
-
-##
-# Image plugin for X11 bitmaps.
-
-
-class XbmImageFile(ImageFile.ImageFile):
- format = "XBM"
- format_description = "X11 Bitmap"
-
- def _open(self):
- m = xbm_head.match(self.fp.read(512))
-
- if not m:
- msg = "not a XBM file"
- raise SyntaxError(msg)
-
- xsize = int(m.group("width"))
- ysize = int(m.group("height"))
-
- if m.group("hotspot"):
- self.info["hotspot"] = (int(m.group("xhot")), int(m.group("yhot")))
-
- self.mode = "1"
- self._size = xsize, ysize
-
- self.tile = [("xbm", (0, 0) + self.size, m.end(), None)]
-
-
-def _save(im, fp, filename):
- if im.mode != "1":
- msg = f"cannot write mode {im.mode} as XBM"
- raise OSError(msg)
-
- fp.write(f"#define im_width {im.size[0]}\n".encode("ascii"))
- fp.write(f"#define im_height {im.size[1]}\n".encode("ascii"))
-
- hotspot = im.encoderinfo.get("hotspot")
- if hotspot:
- fp.write(f"#define im_x_hot {hotspot[0]}\n".encode("ascii"))
- fp.write(f"#define im_y_hot {hotspot[1]}\n".encode("ascii"))
-
- fp.write(b"static char im_bits[] = {\n")
-
- ImageFile._save(im, fp, [("xbm", (0, 0) + im.size, 0, None)])
-
- fp.write(b"};\n")
-
-
-Image.register_open(XbmImageFile.format, XbmImageFile, _accept)
-Image.register_save(XbmImageFile.format, _save)
-
-Image.register_extension(XbmImageFile.format, ".xbm")
-
-Image.register_mime(XbmImageFile.format, "image/xbm")
diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/aiohttp/multipart.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/aiohttp/multipart.py
deleted file mode 100644
index 73801f459aa274ca6aae7bf28a2c5bb3bf075d11..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/aiohttp/multipart.py
+++ /dev/null
@@ -1,961 +0,0 @@
-import base64
-import binascii
-import json
-import re
-import uuid
-import warnings
-import zlib
-from collections import deque
-from types import TracebackType
-from typing import (
- TYPE_CHECKING,
- Any,
- AsyncIterator,
- Deque,
- Dict,
- Iterator,
- List,
- Mapping,
- Optional,
- Sequence,
- Tuple,
- Type,
- Union,
- cast,
-)
-from urllib.parse import parse_qsl, unquote, urlencode
-
-from multidict import CIMultiDict, CIMultiDictProxy, MultiMapping
-
-from .hdrs import (
- CONTENT_DISPOSITION,
- CONTENT_ENCODING,
- CONTENT_LENGTH,
- CONTENT_TRANSFER_ENCODING,
- CONTENT_TYPE,
-)
-from .helpers import CHAR, TOKEN, parse_mimetype, reify
-from .http import HeadersParser
-from .payload import (
- JsonPayload,
- LookupError,
- Order,
- Payload,
- StringPayload,
- get_payload,
- payload_type,
-)
-from .streams import StreamReader
-
-__all__ = (
- "MultipartReader",
- "MultipartWriter",
- "BodyPartReader",
- "BadContentDispositionHeader",
- "BadContentDispositionParam",
- "parse_content_disposition",
- "content_disposition_filename",
-)
-
-
-if TYPE_CHECKING: # pragma: no cover
- from .client_reqrep import ClientResponse
-
-
-class BadContentDispositionHeader(RuntimeWarning):
- pass
-
-
-class BadContentDispositionParam(RuntimeWarning):
- pass
-
-
-def parse_content_disposition(
- header: Optional[str],
-) -> Tuple[Optional[str], Dict[str, str]]:
- def is_token(string: str) -> bool:
- return bool(string) and TOKEN >= set(string)
-
- def is_quoted(string: str) -> bool:
- return string[0] == string[-1] == '"'
-
- def is_rfc5987(string: str) -> bool:
- return is_token(string) and string.count("'") == 2
-
- def is_extended_param(string: str) -> bool:
- return string.endswith("*")
-
- def is_continuous_param(string: str) -> bool:
- pos = string.find("*") + 1
- if not pos:
- return False
- substring = string[pos:-1] if string.endswith("*") else string[pos:]
- return substring.isdigit()
-
- def unescape(text: str, *, chars: str = "".join(map(re.escape, CHAR))) -> str:
- return re.sub(f"\\\\([{chars}])", "\\1", text)
-
- if not header:
- return None, {}
-
- disptype, *parts = header.split(";")
- if not is_token(disptype):
- warnings.warn(BadContentDispositionHeader(header))
- return None, {}
-
- params: Dict[str, str] = {}
- while parts:
- item = parts.pop(0)
-
- if "=" not in item:
- warnings.warn(BadContentDispositionHeader(header))
- return None, {}
-
- key, value = item.split("=", 1)
- key = key.lower().strip()
- value = value.lstrip()
-
- if key in params:
- warnings.warn(BadContentDispositionHeader(header))
- return None, {}
-
- if not is_token(key):
- warnings.warn(BadContentDispositionParam(item))
- continue
-
- elif is_continuous_param(key):
- if is_quoted(value):
- value = unescape(value[1:-1])
- elif not is_token(value):
- warnings.warn(BadContentDispositionParam(item))
- continue
-
- elif is_extended_param(key):
- if is_rfc5987(value):
- encoding, _, value = value.split("'", 2)
- encoding = encoding or "utf-8"
- else:
- warnings.warn(BadContentDispositionParam(item))
- continue
-
- try:
- value = unquote(value, encoding, "strict")
- except UnicodeDecodeError: # pragma: nocover
- warnings.warn(BadContentDispositionParam(item))
- continue
-
- else:
- failed = True
- if is_quoted(value):
- failed = False
- value = unescape(value[1:-1].lstrip("\\/"))
- elif is_token(value):
- failed = False
- elif parts:
- # maybe just ; in filename, in any case this is just
- # one case fix, for proper fix we need to redesign parser
- _value = f"{value};{parts[0]}"
- if is_quoted(_value):
- parts.pop(0)
- value = unescape(_value[1:-1].lstrip("\\/"))
- failed = False
-
- if failed:
- warnings.warn(BadContentDispositionHeader(header))
- return None, {}
-
- params[key] = value
-
- return disptype.lower(), params
-
-
-def content_disposition_filename(
- params: Mapping[str, str], name: str = "filename"
-) -> Optional[str]:
- name_suf = "%s*" % name
- if not params:
- return None
- elif name_suf in params:
- return params[name_suf]
- elif name in params:
- return params[name]
- else:
- parts = []
- fnparams = sorted(
- (key, value) for key, value in params.items() if key.startswith(name_suf)
- )
- for num, (key, value) in enumerate(fnparams):
- _, tail = key.split("*", 1)
- if tail.endswith("*"):
- tail = tail[:-1]
- if tail == str(num):
- parts.append(value)
- else:
- break
- if not parts:
- return None
- value = "".join(parts)
- if "'" in value:
- encoding, _, value = value.split("'", 2)
- encoding = encoding or "utf-8"
- return unquote(value, encoding, "strict")
- return value
-
-
-class MultipartResponseWrapper:
- """Wrapper around the MultipartReader.
-
- It takes care about
- underlying connection and close it when it needs in.
- """
-
- def __init__(
- self,
- resp: "ClientResponse",
- stream: "MultipartReader",
- ) -> None:
- self.resp = resp
- self.stream = stream
-
- def __aiter__(self) -> "MultipartResponseWrapper":
- return self
-
- async def __anext__(
- self,
- ) -> Union["MultipartReader", "BodyPartReader"]:
- part = await self.next()
- if part is None:
- raise StopAsyncIteration
- return part
-
- def at_eof(self) -> bool:
- """Returns True when all response data had been read."""
- return self.resp.content.at_eof()
-
- async def next(
- self,
- ) -> Optional[Union["MultipartReader", "BodyPartReader"]]:
- """Emits next multipart reader object."""
- item = await self.stream.next()
- if self.stream.at_eof():
- await self.release()
- return item
-
- async def release(self) -> None:
- """Release the connection gracefully.
-
- All remaining content is read to the void.
- """
- await self.resp.release()
-
-
-class BodyPartReader:
- """Multipart reader for single body part."""
-
- chunk_size = 8192
-
- def __init__(
- self, boundary: bytes, headers: "CIMultiDictProxy[str]", content: StreamReader
- ) -> None:
- self.headers = headers
- self._boundary = boundary
- self._content = content
- self._at_eof = False
- length = self.headers.get(CONTENT_LENGTH, None)
- self._length = int(length) if length is not None else None
- self._read_bytes = 0
- # TODO: typeing.Deque is not supported by Python 3.5
- self._unread: Deque[bytes] = deque()
- self._prev_chunk: Optional[bytes] = None
- self._content_eof = 0
- self._cache: Dict[str, Any] = {}
-
- def __aiter__(self) -> AsyncIterator["BodyPartReader"]:
- return self # type: ignore[return-value]
-
- async def __anext__(self) -> bytes:
- part = await self.next()
- if part is None:
- raise StopAsyncIteration
- return part
-
- async def next(self) -> Optional[bytes]:
- item = await self.read()
- if not item:
- return None
- return item
-
- async def read(self, *, decode: bool = False) -> bytes:
- """Reads body part data.
-
- decode: Decodes data following by encoding
- method from Content-Encoding header. If it missed
- data remains untouched
- """
- if self._at_eof:
- return b""
- data = bytearray()
- while not self._at_eof:
- data.extend(await self.read_chunk(self.chunk_size))
- if decode:
- return self.decode(data)
- return data
-
- async def read_chunk(self, size: int = chunk_size) -> bytes:
- """Reads body part content chunk of the specified size.
-
- size: chunk size
- """
- if self._at_eof:
- return b""
- if self._length:
- chunk = await self._read_chunk_from_length(size)
- else:
- chunk = await self._read_chunk_from_stream(size)
-
- self._read_bytes += len(chunk)
- if self._read_bytes == self._length:
- self._at_eof = True
- if self._at_eof:
- clrf = await self._content.readline()
- assert (
- b"\r\n" == clrf
- ), "reader did not read all the data or it is malformed"
- return chunk
-
- async def _read_chunk_from_length(self, size: int) -> bytes:
- # Reads body part content chunk of the specified size.
- # The body part must has Content-Length header with proper value.
- assert self._length is not None, "Content-Length required for chunked read"
- chunk_size = min(size, self._length - self._read_bytes)
- chunk = await self._content.read(chunk_size)
- return chunk
-
- async def _read_chunk_from_stream(self, size: int) -> bytes:
- # Reads content chunk of body part with unknown length.
- # The Content-Length header for body part is not necessary.
- assert (
- size >= len(self._boundary) + 2
- ), "Chunk size must be greater or equal than boundary length + 2"
- first_chunk = self._prev_chunk is None
- if first_chunk:
- self._prev_chunk = await self._content.read(size)
-
- chunk = await self._content.read(size)
- self._content_eof += int(self._content.at_eof())
- assert self._content_eof < 3, "Reading after EOF"
- assert self._prev_chunk is not None
- window = self._prev_chunk + chunk
- sub = b"\r\n" + self._boundary
- if first_chunk:
- idx = window.find(sub)
- else:
- idx = window.find(sub, max(0, len(self._prev_chunk) - len(sub)))
- if idx >= 0:
- # pushing boundary back to content
- with warnings.catch_warnings():
- warnings.filterwarnings("ignore", category=DeprecationWarning)
- self._content.unread_data(window[idx:])
- if size > idx:
- self._prev_chunk = self._prev_chunk[:idx]
- chunk = window[len(self._prev_chunk) : idx]
- if not chunk:
- self._at_eof = True
- result = self._prev_chunk
- self._prev_chunk = chunk
- return result
-
- async def readline(self) -> bytes:
- """Reads body part by line by line."""
- if self._at_eof:
- return b""
-
- if self._unread:
- line = self._unread.popleft()
- else:
- line = await self._content.readline()
-
- if line.startswith(self._boundary):
- # the very last boundary may not come with \r\n,
- # so set single rules for everyone
- sline = line.rstrip(b"\r\n")
- boundary = self._boundary
- last_boundary = self._boundary + b"--"
- # ensure that we read exactly the boundary, not something alike
- if sline == boundary or sline == last_boundary:
- self._at_eof = True
- self._unread.append(line)
- return b""
- else:
- next_line = await self._content.readline()
- if next_line.startswith(self._boundary):
- line = line[:-2] # strip CRLF but only once
- self._unread.append(next_line)
-
- return line
-
- async def release(self) -> None:
- """Like read(), but reads all the data to the void."""
- if self._at_eof:
- return
- while not self._at_eof:
- await self.read_chunk(self.chunk_size)
-
- async def text(self, *, encoding: Optional[str] = None) -> str:
- """Like read(), but assumes that body part contains text data."""
- data = await self.read(decode=True)
- # see https://www.w3.org/TR/html5/forms.html#multipart/form-data-encoding-algorithm # NOQA
- # and https://dvcs.w3.org/hg/xhr/raw-file/tip/Overview.html#dom-xmlhttprequest-send # NOQA
- encoding = encoding or self.get_charset(default="utf-8")
- return data.decode(encoding)
-
- async def json(self, *, encoding: Optional[str] = None) -> Optional[Dict[str, Any]]:
- """Like read(), but assumes that body parts contains JSON data."""
- data = await self.read(decode=True)
- if not data:
- return None
- encoding = encoding or self.get_charset(default="utf-8")
- return cast(Dict[str, Any], json.loads(data.decode(encoding)))
-
- async def form(self, *, encoding: Optional[str] = None) -> List[Tuple[str, str]]:
- """Like read(), but assumes that body parts contain form urlencoded data."""
- data = await self.read(decode=True)
- if not data:
- return []
- if encoding is not None:
- real_encoding = encoding
- else:
- real_encoding = self.get_charset(default="utf-8")
- return parse_qsl(
- data.rstrip().decode(real_encoding),
- keep_blank_values=True,
- encoding=real_encoding,
- )
-
- def at_eof(self) -> bool:
- """Returns True if the boundary was reached or False otherwise."""
- return self._at_eof
-
- def decode(self, data: bytes) -> bytes:
- """Decodes data.
-
- Decoding is done according the specified Content-Encoding
- or Content-Transfer-Encoding headers value.
- """
- if CONTENT_TRANSFER_ENCODING in self.headers:
- data = self._decode_content_transfer(data)
- if CONTENT_ENCODING in self.headers:
- return self._decode_content(data)
- return data
-
- def _decode_content(self, data: bytes) -> bytes:
- encoding = self.headers.get(CONTENT_ENCODING, "").lower()
-
- if encoding == "deflate":
- return zlib.decompress(data, -zlib.MAX_WBITS)
- elif encoding == "gzip":
- return zlib.decompress(data, 16 + zlib.MAX_WBITS)
- elif encoding == "identity":
- return data
- else:
- raise RuntimeError(f"unknown content encoding: {encoding}")
-
- def _decode_content_transfer(self, data: bytes) -> bytes:
- encoding = self.headers.get(CONTENT_TRANSFER_ENCODING, "").lower()
-
- if encoding == "base64":
- return base64.b64decode(data)
- elif encoding == "quoted-printable":
- return binascii.a2b_qp(data)
- elif encoding in ("binary", "8bit", "7bit"):
- return data
- else:
- raise RuntimeError(
- "unknown content transfer encoding: {}" "".format(encoding)
- )
-
- def get_charset(self, default: str) -> str:
- """Returns charset parameter from Content-Type header or default."""
- ctype = self.headers.get(CONTENT_TYPE, "")
- mimetype = parse_mimetype(ctype)
- return mimetype.parameters.get("charset", default)
-
- @reify
- def name(self) -> Optional[str]:
- """Returns name specified in Content-Disposition header.
-
- If the header is missing or malformed, returns None.
- """
- _, params = parse_content_disposition(self.headers.get(CONTENT_DISPOSITION))
- return content_disposition_filename(params, "name")
-
- @reify
- def filename(self) -> Optional[str]:
- """Returns filename specified in Content-Disposition header.
-
- Returns None if the header is missing or malformed.
- """
- _, params = parse_content_disposition(self.headers.get(CONTENT_DISPOSITION))
- return content_disposition_filename(params, "filename")
-
-
-@payload_type(BodyPartReader, order=Order.try_first)
-class BodyPartReaderPayload(Payload):
- def __init__(self, value: BodyPartReader, *args: Any, **kwargs: Any) -> None:
- super().__init__(value, *args, **kwargs)
-
- params: Dict[str, str] = {}
- if value.name is not None:
- params["name"] = value.name
- if value.filename is not None:
- params["filename"] = value.filename
-
- if params:
- self.set_content_disposition("attachment", True, **params)
-
- async def write(self, writer: Any) -> None:
- field = self._value
- chunk = await field.read_chunk(size=2**16)
- while chunk:
- await writer.write(field.decode(chunk))
- chunk = await field.read_chunk(size=2**16)
-
-
-class MultipartReader:
- """Multipart body reader."""
-
- #: Response wrapper, used when multipart readers constructs from response.
- response_wrapper_cls = MultipartResponseWrapper
- #: Multipart reader class, used to handle multipart/* body parts.
- #: None points to type(self)
- multipart_reader_cls = None
- #: Body part reader class for non multipart/* content types.
- part_reader_cls = BodyPartReader
-
- def __init__(self, headers: Mapping[str, str], content: StreamReader) -> None:
- self.headers = headers
- self._boundary = ("--" + self._get_boundary()).encode()
- self._content = content
- self._last_part: Optional[Union["MultipartReader", BodyPartReader]] = None
- self._at_eof = False
- self._at_bof = True
- self._unread: List[bytes] = []
-
- def __aiter__(
- self,
- ) -> AsyncIterator["BodyPartReader"]:
- return self # type: ignore[return-value]
-
- async def __anext__(
- self,
- ) -> Optional[Union["MultipartReader", BodyPartReader]]:
- part = await self.next()
- if part is None:
- raise StopAsyncIteration
- return part
-
- @classmethod
- def from_response(
- cls,
- response: "ClientResponse",
- ) -> MultipartResponseWrapper:
- """Constructs reader instance from HTTP response.
-
- :param response: :class:`~aiohttp.client.ClientResponse` instance
- """
- obj = cls.response_wrapper_cls(
- response, cls(response.headers, response.content)
- )
- return obj
-
- def at_eof(self) -> bool:
- """Returns True if the final boundary was reached, false otherwise."""
- return self._at_eof
-
- async def next(
- self,
- ) -> Optional[Union["MultipartReader", BodyPartReader]]:
- """Emits the next multipart body part."""
- # So, if we're at BOF, we need to skip till the boundary.
- if self._at_eof:
- return None
- await self._maybe_release_last_part()
- if self._at_bof:
- await self._read_until_first_boundary()
- self._at_bof = False
- else:
- await self._read_boundary()
- if self._at_eof: # we just read the last boundary, nothing to do there
- return None
- self._last_part = await self.fetch_next_part()
- return self._last_part
-
- async def release(self) -> None:
- """Reads all the body parts to the void till the final boundary."""
- while not self._at_eof:
- item = await self.next()
- if item is None:
- break
- await item.release()
-
- async def fetch_next_part(
- self,
- ) -> Union["MultipartReader", BodyPartReader]:
- """Returns the next body part reader."""
- headers = await self._read_headers()
- return self._get_part_reader(headers)
-
- def _get_part_reader(
- self,
- headers: "CIMultiDictProxy[str]",
- ) -> Union["MultipartReader", BodyPartReader]:
- """Dispatches the response by the `Content-Type` header.
-
- Returns a suitable reader instance.
-
- :param dict headers: Response headers
- """
- ctype = headers.get(CONTENT_TYPE, "")
- mimetype = parse_mimetype(ctype)
-
- if mimetype.type == "multipart":
- if self.multipart_reader_cls is None:
- return type(self)(headers, self._content)
- return self.multipart_reader_cls(headers, self._content)
- else:
- return self.part_reader_cls(self._boundary, headers, self._content)
-
- def _get_boundary(self) -> str:
- mimetype = parse_mimetype(self.headers[CONTENT_TYPE])
-
- assert mimetype.type == "multipart", "multipart/* content type expected"
-
- if "boundary" not in mimetype.parameters:
- raise ValueError(
- "boundary missed for Content-Type: %s" % self.headers[CONTENT_TYPE]
- )
-
- boundary = mimetype.parameters["boundary"]
- if len(boundary) > 70:
- raise ValueError("boundary %r is too long (70 chars max)" % boundary)
-
- return boundary
-
- async def _readline(self) -> bytes:
- if self._unread:
- return self._unread.pop()
- return await self._content.readline()
-
- async def _read_until_first_boundary(self) -> None:
- while True:
- chunk = await self._readline()
- if chunk == b"":
- raise ValueError(
- "Could not find starting boundary %r" % (self._boundary)
- )
- chunk = chunk.rstrip()
- if chunk == self._boundary:
- return
- elif chunk == self._boundary + b"--":
- self._at_eof = True
- return
-
- async def _read_boundary(self) -> None:
- chunk = (await self._readline()).rstrip()
- if chunk == self._boundary:
- pass
- elif chunk == self._boundary + b"--":
- self._at_eof = True
- epilogue = await self._readline()
- next_line = await self._readline()
-
- # the epilogue is expected and then either the end of input or the
- # parent multipart boundary, if the parent boundary is found then
- # it should be marked as unread and handed to the parent for
- # processing
- if next_line[:2] == b"--":
- self._unread.append(next_line)
- # otherwise the request is likely missing an epilogue and both
- # lines should be passed to the parent for processing
- # (this handles the old behavior gracefully)
- else:
- self._unread.extend([next_line, epilogue])
- else:
- raise ValueError(f"Invalid boundary {chunk!r}, expected {self._boundary!r}")
-
- async def _read_headers(self) -> "CIMultiDictProxy[str]":
- lines = [b""]
- while True:
- chunk = await self._content.readline()
- chunk = chunk.strip()
- lines.append(chunk)
- if not chunk:
- break
- parser = HeadersParser()
- headers, raw_headers = parser.parse_headers(lines)
- return headers
-
- async def _maybe_release_last_part(self) -> None:
- """Ensures that the last read body part is read completely."""
- if self._last_part is not None:
- if not self._last_part.at_eof():
- await self._last_part.release()
- self._unread.extend(self._last_part._unread)
- self._last_part = None
-
-
-_Part = Tuple[Payload, str, str]
-
-
-class MultipartWriter(Payload):
- """Multipart body writer."""
-
- def __init__(self, subtype: str = "mixed", boundary: Optional[str] = None) -> None:
- boundary = boundary if boundary is not None else uuid.uuid4().hex
- # The underlying Payload API demands a str (utf-8), not bytes,
- # so we need to ensure we don't lose anything during conversion.
- # As a result, require the boundary to be ASCII only.
- # In both situations.
-
- try:
- self._boundary = boundary.encode("ascii")
- except UnicodeEncodeError:
- raise ValueError("boundary should contain ASCII only chars") from None
- ctype = f"multipart/{subtype}; boundary={self._boundary_value}"
-
- super().__init__(None, content_type=ctype)
-
- self._parts: List[_Part] = []
-
- def __enter__(self) -> "MultipartWriter":
- return self
-
- def __exit__(
- self,
- exc_type: Optional[Type[BaseException]],
- exc_val: Optional[BaseException],
- exc_tb: Optional[TracebackType],
- ) -> None:
- pass
-
- def __iter__(self) -> Iterator[_Part]:
- return iter(self._parts)
-
- def __len__(self) -> int:
- return len(self._parts)
-
- def __bool__(self) -> bool:
- return True
-
- _valid_tchar_regex = re.compile(rb"\A[!#$%&'*+\-.^_`|~\w]+\Z")
- _invalid_qdtext_char_regex = re.compile(rb"[\x00-\x08\x0A-\x1F\x7F]")
-
- @property
- def _boundary_value(self) -> str:
- """Wrap boundary parameter value in quotes, if necessary.
-
- Reads self.boundary and returns a unicode sting.
- """
- # Refer to RFCs 7231, 7230, 5234.
- #
- # parameter = token "=" ( token / quoted-string )
- # token = 1*tchar
- # quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE
- # qdtext = HTAB / SP / %x21 / %x23-5B / %x5D-7E / obs-text
- # obs-text = %x80-FF
- # quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text )
- # tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*"
- # / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
- # / DIGIT / ALPHA
- # ; any VCHAR, except delimiters
- # VCHAR = %x21-7E
- value = self._boundary
- if re.match(self._valid_tchar_regex, value):
- return value.decode("ascii") # cannot fail
-
- if re.search(self._invalid_qdtext_char_regex, value):
- raise ValueError("boundary value contains invalid characters")
-
- # escape %x5C and %x22
- quoted_value_content = value.replace(b"\\", b"\\\\")
- quoted_value_content = quoted_value_content.replace(b'"', b'\\"')
-
- return '"' + quoted_value_content.decode("ascii") + '"'
-
- @property
- def boundary(self) -> str:
- return self._boundary.decode("ascii")
-
- def append(self, obj: Any, headers: Optional[MultiMapping[str]] = None) -> Payload:
- if headers is None:
- headers = CIMultiDict()
-
- if isinstance(obj, Payload):
- obj.headers.update(headers)
- return self.append_payload(obj)
- else:
- try:
- payload = get_payload(obj, headers=headers)
- except LookupError:
- raise TypeError("Cannot create payload from %r" % obj)
- else:
- return self.append_payload(payload)
-
- def append_payload(self, payload: Payload) -> Payload:
- """Adds a new body part to multipart writer."""
- # compression
- encoding: Optional[str] = payload.headers.get(
- CONTENT_ENCODING,
- "",
- ).lower()
- if encoding and encoding not in ("deflate", "gzip", "identity"):
- raise RuntimeError(f"unknown content encoding: {encoding}")
- if encoding == "identity":
- encoding = None
-
- # te encoding
- te_encoding: Optional[str] = payload.headers.get(
- CONTENT_TRANSFER_ENCODING,
- "",
- ).lower()
- if te_encoding not in ("", "base64", "quoted-printable", "binary"):
- raise RuntimeError(
- "unknown content transfer encoding: {}" "".format(te_encoding)
- )
- if te_encoding == "binary":
- te_encoding = None
-
- # size
- size = payload.size
- if size is not None and not (encoding or te_encoding):
- payload.headers[CONTENT_LENGTH] = str(size)
-
- self._parts.append((payload, encoding, te_encoding)) # type: ignore[arg-type]
- return payload
-
- def append_json(
- self, obj: Any, headers: Optional[MultiMapping[str]] = None
- ) -> Payload:
- """Helper to append JSON part."""
- if headers is None:
- headers = CIMultiDict()
-
- return self.append_payload(JsonPayload(obj, headers=headers))
-
- def append_form(
- self,
- obj: Union[Sequence[Tuple[str, str]], Mapping[str, str]],
- headers: Optional[MultiMapping[str]] = None,
- ) -> Payload:
- """Helper to append form urlencoded part."""
- assert isinstance(obj, (Sequence, Mapping))
-
- if headers is None:
- headers = CIMultiDict()
-
- if isinstance(obj, Mapping):
- obj = list(obj.items())
- data = urlencode(obj, doseq=True)
-
- return self.append_payload(
- StringPayload(
- data, headers=headers, content_type="application/x-www-form-urlencoded"
- )
- )
-
- @property
- def size(self) -> Optional[int]:
- """Size of the payload."""
- total = 0
- for part, encoding, te_encoding in self._parts:
- if encoding or te_encoding or part.size is None:
- return None
-
- total += int(
- 2
- + len(self._boundary)
- + 2
- + part.size # b'--'+self._boundary+b'\r\n'
- + len(part._binary_headers)
- + 2 # b'\r\n'
- )
-
- total += 2 + len(self._boundary) + 4 # b'--'+self._boundary+b'--\r\n'
- return total
-
- async def write(self, writer: Any, close_boundary: bool = True) -> None:
- """Write body."""
- for part, encoding, te_encoding in self._parts:
- await writer.write(b"--" + self._boundary + b"\r\n")
- await writer.write(part._binary_headers)
-
- if encoding or te_encoding:
- w = MultipartPayloadWriter(writer)
- if encoding:
- w.enable_compression(encoding)
- if te_encoding:
- w.enable_encoding(te_encoding)
- await part.write(w) # type: ignore[arg-type]
- await w.write_eof()
- else:
- await part.write(writer)
-
- await writer.write(b"\r\n")
-
- if close_boundary:
- await writer.write(b"--" + self._boundary + b"--\r\n")
-
-
-class MultipartPayloadWriter:
- def __init__(self, writer: Any) -> None:
- self._writer = writer
- self._encoding: Optional[str] = None
- self._compress: Any = None
- self._encoding_buffer: Optional[bytearray] = None
-
- def enable_encoding(self, encoding: str) -> None:
- if encoding == "base64":
- self._encoding = encoding
- self._encoding_buffer = bytearray()
- elif encoding == "quoted-printable":
- self._encoding = "quoted-printable"
-
- def enable_compression(
- self, encoding: str = "deflate", strategy: int = zlib.Z_DEFAULT_STRATEGY
- ) -> None:
- zlib_mode = 16 + zlib.MAX_WBITS if encoding == "gzip" else -zlib.MAX_WBITS
- self._compress = zlib.compressobj(wbits=zlib_mode, strategy=strategy)
-
- async def write_eof(self) -> None:
- if self._compress is not None:
- chunk = self._compress.flush()
- if chunk:
- self._compress = None
- await self.write(chunk)
-
- if self._encoding == "base64":
- if self._encoding_buffer:
- await self._writer.write(base64.b64encode(self._encoding_buffer))
-
- async def write(self, chunk: bytes) -> None:
- if self._compress is not None:
- if chunk:
- chunk = self._compress.compress(chunk)
- if not chunk:
- return
-
- if self._encoding == "base64":
- buf = self._encoding_buffer
- assert buf is not None
- buf.extend(chunk)
-
- if buf:
- div, mod = divmod(len(buf), 3)
- enc_chunk, self._encoding_buffer = (buf[: div * 3], buf[div * 3 :])
- if enc_chunk:
- b64chunk = base64.b64encode(enc_chunk)
- await self._writer.write(b64chunk)
- elif self._encoding == "quoted-printable":
- await self._writer.write(binascii.b2a_qp(chunk))
- else:
- await self._writer.write(chunk)
diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio/components/number.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio/components/number.py
deleted file mode 100644
index 5d2b9fcccc1469d0fee4c79c77011d4d8a67bcb0..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio/components/number.py
+++ /dev/null
@@ -1,244 +0,0 @@
-"""gr.Number() component."""
-
-from __future__ import annotations
-
-import math
-from typing import Callable, Literal
-
-import numpy as np
-from gradio_client.documentation import document, set_documentation_group
-from gradio_client.serializing import NumberSerializable
-
-from gradio.components.base import FormComponent, IOComponent, _Keywords
-from gradio.events import (
- Changeable,
- Focusable,
- Inputable,
- Submittable,
-)
-from gradio.exceptions import Error
-from gradio.interpretation import NeighborInterpretable
-
-set_documentation_group("component")
-
-
-@document()
-class Number(
- FormComponent,
- Changeable,
- Inputable,
- Submittable,
- Focusable,
- IOComponent,
- NumberSerializable,
- NeighborInterpretable,
-):
- """
- Creates a numeric field for user to enter numbers as input or display numeric output.
- Preprocessing: passes field value as a {float} or {int} into the function, depending on `precision`.
- Postprocessing: expects an {int} or {float} returned from the function and sets field value to it.
- Examples-format: a {float} or {int} representing the number's value.
-
- Demos: tax_calculator, titanic_survival, blocks_simple_squares
- """
-
- def __init__(
- self,
- value: float | Callable | None = None,
- *,
- label: str | None = None,
- info: str | None = None,
- every: float | None = None,
- show_label: bool | None = None,
- container: bool = True,
- scale: int | None = None,
- min_width: int = 160,
- interactive: bool | None = None,
- visible: bool = True,
- elem_id: str | None = None,
- elem_classes: list[str] | str | None = None,
- precision: int | None = None,
- minimum: float | None = None,
- maximum: float | None = None,
- step: float = 1,
- **kwargs,
- ):
- """
- Parameters:
- value: default value. If callable, the function will be called whenever the app loads to set the initial value of the component.
- label: component name in interface.
- info: additional component description.
- every: If `value` is a callable, run the function 'every' number of seconds while the client connection is open. Has no effect otherwise. Queue must be enabled. The event can be accessed (e.g. to cancel it) via this component's .load_event attribute.
- show_label: if True, will display label.
- container: If True, will place the component in a container - providing some extra padding around the border.
- scale: relative width compared to adjacent Components in a Row. For example, if Component A has scale=2, and Component B has scale=1, A will be twice as wide as B. Should be an integer.
- min_width: minimum pixel width, will wrap if not sufficient screen space to satisfy this value. If a certain scale value results in this Component being narrower than min_width, the min_width parameter will be respected first.
- interactive: if True, will be editable; if False, editing will be disabled. If not provided, this is inferred based on whether the component is used as an input or output.
- visible: If False, component will be hidden.
- elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
- elem_classes: An optional list of strings that are assigned as the classes of this component in the HTML DOM. Can be used for targeting CSS styles.
- precision: Precision to round input/output to. If set to 0, will round to nearest integer and convert type to int. If None, no rounding happens.
- minimum: Minimum value. Only applied when component is used as an input. If a user provides a smaller value, a gr.Error exception is raised by the backend.
- maximum: Maximum value. Only applied when component is used as an input. If a user provides a larger value, a gr.Error exception is raised by the backend.
- step: The interval between allowed numbers in the component. Can be used along with optional parameters `minimum` and `maximum` to create a range of legal values starting from `minimum` and incrementing according to this parameter.
- """
- self.precision = precision
- self.minimum = minimum
- self.maximum = maximum
- self.step = step
-
- IOComponent.__init__(
- self,
- label=label,
- info=info,
- every=every,
- show_label=show_label,
- container=container,
- scale=scale,
- min_width=min_width,
- interactive=interactive,
- visible=visible,
- elem_id=elem_id,
- elem_classes=elem_classes,
- value=value,
- **kwargs,
- )
- NeighborInterpretable.__init__(self)
-
- @staticmethod
- def _round_to_precision(num: float | int, precision: int | None) -> float | int:
- """
- Round to a given precision.
-
- If precision is None, no rounding happens. If 0, num is converted to int.
-
- Parameters:
- num: Number to round.
- precision: Precision to round to.
- Returns:
- rounded number
- """
- if precision is None:
- return float(num)
- elif precision == 0:
- return int(round(num, precision))
- else:
- return round(num, precision)
-
- def get_config(self):
- return {
- "value": self.value,
- "minimum": self.minimum,
- "maximum": self.maximum,
- "step": self.step,
- "container": self.container,
- **IOComponent.get_config(self),
- }
-
- @staticmethod
- def update(
- value: float | Literal[_Keywords.NO_VALUE] | None = _Keywords.NO_VALUE,
- minimum: float | None = None,
- maximum: float | None = None,
- step: float = 1,
- label: str | None = None,
- info: str | None = None,
- show_label: bool | None = None,
- container: bool | None = None,
- scale: int | None = None,
- min_width: int | None = None,
- interactive: bool | None = None,
- visible: bool | None = None,
- ):
- return {
- "label": label,
- "info": info,
- "show_label": show_label,
- "container": container,
- "scale": scale,
- "min_width": min_width,
- "visible": visible,
- "value": value,
- "minimum": minimum,
- "maximum": maximum,
- "step": step,
- "interactive": interactive,
- "__type__": "update",
- }
-
- def preprocess(self, x: float | None) -> float | None:
- """
- Parameters:
- x: numeric input
- Returns:
- number representing function input
- """
- if x is None:
- return None
- elif self.minimum is not None and x < self.minimum:
- raise Error(f"Value {x} is less than minimum value {self.minimum}.")
- elif self.maximum is not None and x > self.maximum:
- raise Error(f"Value {x} is greater than maximum value {self.maximum}.")
- return self._round_to_precision(x, self.precision)
-
- def postprocess(self, y: float | None) -> float | None:
- """
- Any postprocessing needed to be performed on function output.
-
- Parameters:
- y: numeric output
- Returns:
- number representing function output
- """
- if y is None:
- return None
- return self._round_to_precision(y, self.precision)
-
- def set_interpret_parameters(
- self, steps: int = 3, delta: float = 1, delta_type: str = "percent"
- ):
- """
- Calculates interpretation scores of numeric values close to the input number.
- Parameters:
- steps: Number of nearby values to measure in each direction (above and below the input number).
- delta: Size of step in each direction between nearby values.
- delta_type: "percent" if delta step between nearby values should be a calculated as a percent, or "absolute" if delta should be a constant step change.
- """
- self.interpretation_steps = steps
- self.interpretation_delta = delta
- self.interpretation_delta_type = delta_type
- return self
-
- def get_interpretation_neighbors(self, x: float | int) -> tuple[list[float], dict]:
- x = self._round_to_precision(x, self.precision)
- if self.interpretation_delta_type == "percent":
- delta = 1.0 * self.interpretation_delta * x / 100
- elif self.interpretation_delta_type == "absolute":
- delta = self.interpretation_delta
- else:
- delta = self.interpretation_delta
- if self.precision == 0 and math.floor(delta) != delta:
- raise ValueError(
- f"Delta value {delta} is not an integer and precision=0. Cannot generate valid set of neighbors. "
- "If delta_type='percent', pick a value of delta such that x * delta is an integer. "
- "If delta_type='absolute', pick a value of delta that is an integer."
- )
- # run_interpretation will preprocess the neighbors so no need to convert to int here
- negatives = (
- np.array(x) + np.arange(-self.interpretation_steps, 0) * delta
- ).tolist()
- positives = (
- np.array(x) + np.arange(1, self.interpretation_steps + 1) * delta
- ).tolist()
- return negatives + positives, {}
-
- def get_interpretation_scores(
- self, x: float, neighbors: list[float], scores: list[float | None], **kwargs
- ) -> list[tuple[float, float | None]]:
- """
- Returns:
- Each tuple set represents a numeric value near the input and its corresponding interpretation score.
- """
- interpretation = list(zip(neighbors, scores))
- interpretation.insert(int(len(interpretation) / 2), (x, None))
- return interpretation
diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio/components/radio.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio/components/radio.py
deleted file mode 100644
index 3e8f79ab9ff1259876ca2ad1fe3f3e078b92681c..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio/components/radio.py
+++ /dev/null
@@ -1,197 +0,0 @@
-"""gr.Radio() component."""
-
-from __future__ import annotations
-
-from typing import Any, Callable, Literal
-
-from gradio_client.documentation import document, set_documentation_group
-from gradio_client.serializing import StringSerializable
-
-from gradio.components.base import FormComponent, IOComponent, _Keywords
-from gradio.deprecation import warn_deprecation, warn_style_method_deprecation
-from gradio.events import Changeable, EventListenerMethod, Inputable, Selectable
-from gradio.interpretation import NeighborInterpretable
-
-set_documentation_group("component")
-
-
-@document()
-class Radio(
- FormComponent,
- Selectable,
- Changeable,
- Inputable,
- IOComponent,
- StringSerializable,
- NeighborInterpretable,
-):
- """
- Creates a set of (string or numeric type) radio buttons of which only one can be selected.
- Preprocessing: passes the value of the selected radio button as a {str} or {int} or {float} or its index as an {int} into the function, depending on `type`.
- Postprocessing: expects a {str} or {int} or {float} corresponding to the value of the radio button to be selected.
- Examples-format: a {str} representing the radio option to select.
-
- Demos: sentence_builder, titanic_survival, blocks_essay
- """
-
- def __init__(
- self,
- choices: list[str | int | float] | None = None,
- *,
- value: str | int | float | Callable | None = None,
- type: str = "value",
- label: str | None = None,
- info: str | None = None,
- every: float | None = None,
- show_label: bool | None = None,
- container: bool = True,
- scale: int | None = None,
- min_width: int = 160,
- interactive: bool | None = None,
- visible: bool = True,
- elem_id: str | None = None,
- elem_classes: list[str] | str | None = None,
- **kwargs,
- ):
- """
- Parameters:
- choices: list of options to select from.
- value: the button selected by default. If None, no button is selected by default. If callable, the function will be called whenever the app loads to set the initial value of the component.
- type: Type of value to be returned by component. "value" returns the string of the choice selected, "index" returns the index of the choice selected.
- label: component name in interface.
- info: additional component description.
- every: If `value` is a callable, run the function 'every' number of seconds while the client connection is open. Has no effect otherwise. Queue must be enabled. The event can be accessed (e.g. to cancel it) via this component's .load_event attribute.
- show_label: if True, will display label.
- container: If True, will place the component in a container - providing some extra padding around the border.
- scale: relative width compared to adjacent Components in a Row. For example, if Component A has scale=2, and Component B has scale=1, A will be twice as wide as B. Should be an integer.
- min_width: minimum pixel width, will wrap if not sufficient screen space to satisfy this value. If a certain scale value results in this Component being narrower than min_width, the min_width parameter will be respected first.
- interactive: if True, choices in this radio group will be selectable; if False, selection will be disabled. If not provided, this is inferred based on whether the component is used as an input or output.
- visible: If False, component will be hidden.
- elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
- elem_classes: An optional list of strings that are assigned as the classes of this component in the HTML DOM. Can be used for targeting CSS styles.
- """
- self.choices = choices or []
- valid_types = ["value", "index"]
- if type not in valid_types:
- raise ValueError(
- f"Invalid value for parameter `type`: {type}. Please choose from one of: {valid_types}"
- )
- self.type = type
- self.select: EventListenerMethod
- """
- Event listener for when the user selects Radio option.
- Uses event data gradio.SelectData to carry `value` referring to label of selected option, and `index` to refer to index.
- See EventData documentation on how to use this event data.
- """
- IOComponent.__init__(
- self,
- label=label,
- info=info,
- every=every,
- show_label=show_label,
- container=container,
- scale=scale,
- min_width=min_width,
- interactive=interactive,
- visible=visible,
- elem_id=elem_id,
- elem_classes=elem_classes,
- value=value,
- **kwargs,
- )
- NeighborInterpretable.__init__(self)
-
- def get_config(self):
- return {
- "choices": self.choices,
- "value": self.value,
- **IOComponent.get_config(self),
- }
-
- def example_inputs(self) -> dict[str, Any]:
- return {
- "raw": self.choices[0] if self.choices else None,
- "serialized": self.choices[0] if self.choices else None,
- }
-
- @staticmethod
- def update(
- value: str
- | int
- | float
- | Literal[_Keywords.NO_VALUE]
- | None = _Keywords.NO_VALUE,
- choices: list[str | int | float] | None = None,
- label: str | None = None,
- info: str | None = None,
- show_label: bool | None = None,
- container: bool | None = None,
- scale: int | None = None,
- min_width: int | None = None,
- interactive: bool | None = None,
- visible: bool | None = None,
- ):
- return {
- "choices": choices,
- "label": label,
- "info": info,
- "show_label": show_label,
- "container": container,
- "scale": scale,
- "min_width": min_width,
- "interactive": interactive,
- "visible": visible,
- "value": value,
- "__type__": "update",
- }
-
- def preprocess(self, x: str | int | float | None) -> str | int | float | None:
- """
- Parameters:
- x: selected choice
- Returns:
- selected choice as string or index within choice list
- """
- if self.type == "value":
- return x
- elif self.type == "index":
- if x is None:
- return None
- else:
- return self.choices.index(x)
- else:
- raise ValueError(
- f"Unknown type: {self.type}. Please choose from: 'value', 'index'."
- )
-
- def get_interpretation_neighbors(self, x):
- choices = list(self.choices)
- choices.remove(x)
- return choices, {}
-
- def get_interpretation_scores(
- self, x, neighbors, scores: list[float | None], **kwargs
- ) -> list:
- """
- Returns:
- Each value represents the interpretation score corresponding to each choice.
- """
- scores.insert(self.choices.index(x), None)
- return scores
-
- def style(
- self,
- *,
- item_container: bool | None = None,
- container: bool | None = None,
- **kwargs,
- ):
- """
- This method is deprecated. Please set these arguments in the constructor instead.
- """
- warn_style_method_deprecation()
- if item_container is not None:
- warn_deprecation("The `item_container` parameter is deprecated.")
- if container is not None:
- self.container = container
- return self
diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/matplotlib/_mathtext.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/matplotlib/_mathtext.py
deleted file mode 100644
index 3a934c21fd50764515fe4c56810489c50510079b..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/matplotlib/_mathtext.py
+++ /dev/null
@@ -1,2597 +0,0 @@
-"""
-Implementation details for :mod:`.mathtext`.
-"""
-
-import copy
-from collections import namedtuple
-import enum
-import functools
-import logging
-import os
-import re
-import types
-import unicodedata
-
-import numpy as np
-from pyparsing import (
- Empty, Forward, Literal, NotAny, oneOf, OneOrMore, Optional,
- ParseBaseException, ParseException, ParseExpression, ParseFatalException,
- ParserElement, ParseResults, QuotedString, Regex, StringEnd, ZeroOrMore,
- pyparsing_common)
-
-import matplotlib as mpl
-from . import _api, cbook
-from ._mathtext_data import (
- latex_to_bakoma, stix_glyph_fixes, stix_virtual_fonts, tex2uni)
-from .font_manager import FontProperties, findfont, get_font
-from .ft2font import FT2Image, KERNING_DEFAULT
-
-
-ParserElement.enablePackrat()
-_log = logging.getLogger("matplotlib.mathtext")
-
-
-##############################################################################
-# FONTS
-
-
-@_api.delete_parameter("3.6", "math")
-def get_unicode_index(symbol, math=False): # Publicly exported.
- r"""
- Return the integer index (from the Unicode table) of *symbol*.
-
- Parameters
- ----------
- symbol : str
- A single (Unicode) character, a TeX command (e.g. r'\pi') or a Type1
- symbol name (e.g. 'phi').
- math : bool, default: False
- If True (deprecated), replace ASCII hyphen-minus by Unicode minus.
- """
- # From UTF #25: U+2212 minus sign is the preferred
- # representation of the unary and binary minus sign rather than
- # the ASCII-derived U+002D hyphen-minus, because minus sign is
- # unambiguous and because it is rendered with a more desirable
- # length, usually longer than a hyphen.
- # Remove this block when the 'math' parameter is deleted.
- if math and symbol == '-':
- return 0x2212
- try: # This will succeed if symbol is a single Unicode char
- return ord(symbol)
- except TypeError:
- pass
- try: # Is symbol a TeX symbol (i.e. \alpha)
- return tex2uni[symbol.strip("\\")]
- except KeyError as err:
- raise ValueError(
- "'{}' is not a valid Unicode character or TeX/Type1 symbol"
- .format(symbol)) from err
-
-
-VectorParse = namedtuple("VectorParse", "width height depth glyphs rects",
- module="matplotlib.mathtext")
-VectorParse.__doc__ = r"""
-The namedtuple type returned by ``MathTextParser("path").parse(...)``.
-
-This tuple contains the global metrics (*width*, *height*, *depth*), a list of
-*glyphs* (including their positions) and of *rect*\angles.
-"""
-
-
-RasterParse = namedtuple("RasterParse", "ox oy width height depth image",
- module="matplotlib.mathtext")
-RasterParse.__doc__ = r"""
-The namedtuple type returned by ``MathTextParser("agg").parse(...)``.
-
-This tuple contains the global metrics (*width*, *height*, *depth*), and a
-raster *image*. The offsets *ox*, *oy* are always zero.
-"""
-
-
-class Output:
- r"""
- Result of `ship`\ping a box: lists of positioned glyphs and rectangles.
-
- This class is not exposed to end users, but converted to a `VectorParse` or
- a `RasterParse` by `.MathTextParser.parse`.
- """
-
- def __init__(self, box):
- self.box = box
- self.glyphs = [] # (ox, oy, info)
- self.rects = [] # (x1, y1, x2, y2)
-
- def to_vector(self):
- w, h, d = map(
- np.ceil, [self.box.width, self.box.height, self.box.depth])
- gs = [(info.font, info.fontsize, info.num, ox, h - oy + info.offset)
- for ox, oy, info in self.glyphs]
- rs = [(x1, h - y2, x2 - x1, y2 - y1)
- for x1, y1, x2, y2 in self.rects]
- return VectorParse(w, h + d, d, gs, rs)
-
- def to_raster(self):
- # Metrics y's and mathtext y's are oriented in opposite directions,
- # hence the switch between ymin and ymax.
- xmin = min([*[ox + info.metrics.xmin for ox, oy, info in self.glyphs],
- *[x1 for x1, y1, x2, y2 in self.rects], 0]) - 1
- ymin = min([*[oy - info.metrics.ymax for ox, oy, info in self.glyphs],
- *[y1 for x1, y1, x2, y2 in self.rects], 0]) - 1
- xmax = max([*[ox + info.metrics.xmax for ox, oy, info in self.glyphs],
- *[x2 for x1, y1, x2, y2 in self.rects], 0]) + 1
- ymax = max([*[oy - info.metrics.ymin for ox, oy, info in self.glyphs],
- *[y2 for x1, y1, x2, y2 in self.rects], 0]) + 1
- w = xmax - xmin
- h = ymax - ymin - self.box.depth
- d = ymax - ymin - self.box.height
- image = FT2Image(np.ceil(w), np.ceil(h + max(d, 0)))
-
- # Ideally, we could just use self.glyphs and self.rects here, shifting
- # their coordinates by (-xmin, -ymin), but this yields slightly
- # different results due to floating point slop; shipping twice is the
- # old approach and keeps baseline images backcompat.
- shifted = ship(self.box, (-xmin, -ymin))
-
- for ox, oy, info in shifted.glyphs:
- info.font.draw_glyph_to_bitmap(
- image, ox, oy - info.metrics.iceberg, info.glyph,
- antialiased=mpl.rcParams['text.antialiased'])
- for x1, y1, x2, y2 in shifted.rects:
- height = max(int(y2 - y1) - 1, 0)
- if height == 0:
- center = (y2 + y1) / 2
- y = int(center - (height + 1) / 2)
- else:
- y = int(y1)
- image.draw_rect_filled(int(x1), y, np.ceil(x2), y + height)
- return RasterParse(0, 0, w, h + d, d, image)
-
-
-class Fonts:
- """
- An abstract base class for a system of fonts to use for mathtext.
-
- The class must be able to take symbol keys and font file names and
- return the character metrics. It also delegates to a backend class
- to do the actual drawing.
- """
-
- def __init__(self, default_font_prop, load_glyph_flags):
- """
- Parameters
- ----------
- default_font_prop : `~.font_manager.FontProperties`
- The default non-math font, or the base font for Unicode (generic)
- font rendering.
- load_glyph_flags : int
- Flags passed to the glyph loader (e.g. ``FT_Load_Glyph`` and
- ``FT_Load_Char`` for FreeType-based fonts).
- """
- self.default_font_prop = default_font_prop
- self.load_glyph_flags = load_glyph_flags
-
- def get_kern(self, font1, fontclass1, sym1, fontsize1,
- font2, fontclass2, sym2, fontsize2, dpi):
- """
- Get the kerning distance for font between *sym1* and *sym2*.
-
- See `~.Fonts.get_metrics` for a detailed description of the parameters.
- """
- return 0.
-
- def get_metrics(self, font, font_class, sym, fontsize, dpi):
- r"""
- Parameters
- ----------
- font : str
- One of the TeX font names: "tt", "it", "rm", "cal", "sf", "bf",
- "default", "regular", "bb", "frak", "scr". "default" and "regular"
- are synonyms and use the non-math font.
- font_class : str
- One of the TeX font names (as for *font*), but **not** "bb",
- "frak", or "scr". This is used to combine two font classes. The
- only supported combination currently is ``get_metrics("frak", "bf",
- ...)``.
- sym : str
- A symbol in raw TeX form, e.g., "1", "x", or "\sigma".
- fontsize : float
- Font size in points.
- dpi : float
- Rendering dots-per-inch.
-
- Returns
- -------
- object
-
- The returned object has the following attributes (all floats,
- except *slanted*):
-
- - *advance*: The advance distance (in points) of the glyph.
- - *height*: The height of the glyph in points.
- - *width*: The width of the glyph in points.
- - *xmin*, *xmax*, *ymin*, *ymax*: The ink rectangle of the glyph
- - *iceberg*: The distance from the baseline to the top of the
- glyph. (This corresponds to TeX's definition of "height".)
- - *slanted*: Whether the glyph should be considered as "slanted"
- (currently used for kerning sub/superscripts).
- """
- info = self._get_info(font, font_class, sym, fontsize, dpi)
- return info.metrics
-
- def render_glyph(
- self, output, ox, oy, font, font_class, sym, fontsize, dpi):
- """
- At position (*ox*, *oy*), draw the glyph specified by the remaining
- parameters (see `get_metrics` for their detailed description).
- """
- info = self._get_info(font, font_class, sym, fontsize, dpi)
- output.glyphs.append((ox, oy, info))
-
- def render_rect_filled(self, output, x1, y1, x2, y2):
- """
- Draw a filled rectangle from (*x1*, *y1*) to (*x2*, *y2*).
- """
- output.rects.append((x1, y1, x2, y2))
-
- def get_xheight(self, font, fontsize, dpi):
- """
- Get the xheight for the given *font* and *fontsize*.
- """
- raise NotImplementedError()
-
- def get_underline_thickness(self, font, fontsize, dpi):
- """
- Get the line thickness that matches the given font. Used as a
- base unit for drawing lines such as in a fraction or radical.
- """
- raise NotImplementedError()
-
- def get_used_characters(self):
- """
- Get the set of characters that were used in the math
- expression. Used by backends that need to subset fonts so
- they know which glyphs to include.
- """
- return self.used_characters
-
- def get_sized_alternatives_for_symbol(self, fontname, sym):
- """
- Override if your font provides multiple sizes of the same
- symbol. Should return a list of symbols matching *sym* in
- various sizes. The expression renderer will select the most
- appropriate size for a given situation from this list.
- """
- return [(fontname, sym)]
-
-
-class TruetypeFonts(Fonts):
- """
- A generic base class for all font setups that use Truetype fonts
- (through FT2Font).
- """
-
- def __init__(self, *args, **kwargs):
- super().__init__(*args, **kwargs)
- # Per-instance cache.
- self._get_info = functools.lru_cache(None)(self._get_info)
- self._fonts = {}
-
- filename = findfont(self.default_font_prop)
- default_font = get_font(filename)
- self._fonts['default'] = default_font
- self._fonts['regular'] = default_font
-
- def _get_font(self, font):
- if font in self.fontmap:
- basename = self.fontmap[font]
- else:
- basename = font
- cached_font = self._fonts.get(basename)
- if cached_font is None and os.path.exists(basename):
- cached_font = get_font(basename)
- self._fonts[basename] = cached_font
- self._fonts[cached_font.postscript_name] = cached_font
- self._fonts[cached_font.postscript_name.lower()] = cached_font
- return cached_font
-
- def _get_offset(self, font, glyph, fontsize, dpi):
- if font.postscript_name == 'Cmex10':
- return (glyph.height / 64 / 2) + (fontsize/3 * dpi/72)
- return 0.
-
- # The return value of _get_info is cached per-instance.
- def _get_info(self, fontname, font_class, sym, fontsize, dpi):
- font, num, slanted = self._get_glyph(fontname, font_class, sym)
- font.set_size(fontsize, dpi)
- glyph = font.load_char(num, flags=self.load_glyph_flags)
-
- xmin, ymin, xmax, ymax = [val/64.0 for val in glyph.bbox]
- offset = self._get_offset(font, glyph, fontsize, dpi)
- metrics = types.SimpleNamespace(
- advance = glyph.linearHoriAdvance/65536.0,
- height = glyph.height/64.0,
- width = glyph.width/64.0,
- xmin = xmin,
- xmax = xmax,
- ymin = ymin+offset,
- ymax = ymax+offset,
- # iceberg is the equivalent of TeX's "height"
- iceberg = glyph.horiBearingY/64.0 + offset,
- slanted = slanted
- )
-
- return types.SimpleNamespace(
- font = font,
- fontsize = fontsize,
- postscript_name = font.postscript_name,
- metrics = metrics,
- num = num,
- glyph = glyph,
- offset = offset
- )
-
- def get_xheight(self, fontname, fontsize, dpi):
- font = self._get_font(fontname)
- font.set_size(fontsize, dpi)
- pclt = font.get_sfnt_table('pclt')
- if pclt is None:
- # Some fonts don't store the xHeight, so we do a poor man's xHeight
- metrics = self.get_metrics(
- fontname, mpl.rcParams['mathtext.default'], 'x', fontsize, dpi)
- return metrics.iceberg
- xHeight = (pclt['xHeight'] / 64.0) * (fontsize / 12.0) * (dpi / 100.0)
- return xHeight
-
- def get_underline_thickness(self, font, fontsize, dpi):
- # This function used to grab underline thickness from the font
- # metrics, but that information is just too un-reliable, so it
- # is now hardcoded.
- return ((0.75 / 12.0) * fontsize * dpi) / 72.0
-
- def get_kern(self, font1, fontclass1, sym1, fontsize1,
- font2, fontclass2, sym2, fontsize2, dpi):
- if font1 == font2 and fontsize1 == fontsize2:
- info1 = self._get_info(font1, fontclass1, sym1, fontsize1, dpi)
- info2 = self._get_info(font2, fontclass2, sym2, fontsize2, dpi)
- font = info1.font
- return font.get_kerning(info1.num, info2.num, KERNING_DEFAULT) / 64
- return super().get_kern(font1, fontclass1, sym1, fontsize1,
- font2, fontclass2, sym2, fontsize2, dpi)
-
-
-class BakomaFonts(TruetypeFonts):
- """
- Use the Bakoma TrueType fonts for rendering.
-
- Symbols are strewn about a number of font files, each of which has
- its own proprietary 8-bit encoding.
- """
- _fontmap = {
- 'cal': 'cmsy10',
- 'rm': 'cmr10',
- 'tt': 'cmtt10',
- 'it': 'cmmi10',
- 'bf': 'cmb10',
- 'sf': 'cmss10',
- 'ex': 'cmex10',
- }
-
- def __init__(self, *args, **kwargs):
- self._stix_fallback = StixFonts(*args, **kwargs)
-
- super().__init__(*args, **kwargs)
- self.fontmap = {}
- for key, val in self._fontmap.items():
- fullpath = findfont(val)
- self.fontmap[key] = fullpath
- self.fontmap[val] = fullpath
-
- _slanted_symbols = set(r"\int \oint".split())
-
- def _get_glyph(self, fontname, font_class, sym):
- font = None
- if fontname in self.fontmap and sym in latex_to_bakoma:
- basename, num = latex_to_bakoma[sym]
- slanted = (basename == "cmmi10") or sym in self._slanted_symbols
- font = self._get_font(basename)
- elif len(sym) == 1:
- slanted = (fontname == "it")
- font = self._get_font(fontname)
- if font is not None:
- num = ord(sym)
- if font is not None and font.get_char_index(num) != 0:
- return font, num, slanted
- else:
- return self._stix_fallback._get_glyph(fontname, font_class, sym)
-
- # The Bakoma fonts contain many pre-sized alternatives for the
- # delimiters. The AutoSizedChar class will use these alternatives
- # and select the best (closest sized) glyph.
- _size_alternatives = {
- '(': [('rm', '('), ('ex', '\xa1'), ('ex', '\xb3'),
- ('ex', '\xb5'), ('ex', '\xc3')],
- ')': [('rm', ')'), ('ex', '\xa2'), ('ex', '\xb4'),
- ('ex', '\xb6'), ('ex', '\x21')],
- '{': [('cal', '{'), ('ex', '\xa9'), ('ex', '\x6e'),
- ('ex', '\xbd'), ('ex', '\x28')],
- '}': [('cal', '}'), ('ex', '\xaa'), ('ex', '\x6f'),
- ('ex', '\xbe'), ('ex', '\x29')],
- # The fourth size of '[' is mysteriously missing from the BaKoMa
- # font, so I've omitted it for both '[' and ']'
- '[': [('rm', '['), ('ex', '\xa3'), ('ex', '\x68'),
- ('ex', '\x22')],
- ']': [('rm', ']'), ('ex', '\xa4'), ('ex', '\x69'),
- ('ex', '\x23')],
- r'\lfloor': [('ex', '\xa5'), ('ex', '\x6a'),
- ('ex', '\xb9'), ('ex', '\x24')],
- r'\rfloor': [('ex', '\xa6'), ('ex', '\x6b'),
- ('ex', '\xba'), ('ex', '\x25')],
- r'\lceil': [('ex', '\xa7'), ('ex', '\x6c'),
- ('ex', '\xbb'), ('ex', '\x26')],
- r'\rceil': [('ex', '\xa8'), ('ex', '\x6d'),
- ('ex', '\xbc'), ('ex', '\x27')],
- r'\langle': [('ex', '\xad'), ('ex', '\x44'),
- ('ex', '\xbf'), ('ex', '\x2a')],
- r'\rangle': [('ex', '\xae'), ('ex', '\x45'),
- ('ex', '\xc0'), ('ex', '\x2b')],
- r'\__sqrt__': [('ex', '\x70'), ('ex', '\x71'),
- ('ex', '\x72'), ('ex', '\x73')],
- r'\backslash': [('ex', '\xb2'), ('ex', '\x2f'),
- ('ex', '\xc2'), ('ex', '\x2d')],
- r'/': [('rm', '/'), ('ex', '\xb1'), ('ex', '\x2e'),
- ('ex', '\xcb'), ('ex', '\x2c')],
- r'\widehat': [('rm', '\x5e'), ('ex', '\x62'), ('ex', '\x63'),
- ('ex', '\x64')],
- r'\widetilde': [('rm', '\x7e'), ('ex', '\x65'), ('ex', '\x66'),
- ('ex', '\x67')],
- r'<': [('cal', 'h'), ('ex', 'D')],
- r'>': [('cal', 'i'), ('ex', 'E')]
- }
-
- for alias, target in [(r'\leftparen', '('),
- (r'\rightparent', ')'),
- (r'\leftbrace', '{'),
- (r'\rightbrace', '}'),
- (r'\leftbracket', '['),
- (r'\rightbracket', ']'),
- (r'\{', '{'),
- (r'\}', '}'),
- (r'\[', '['),
- (r'\]', ']')]:
- _size_alternatives[alias] = _size_alternatives[target]
-
- def get_sized_alternatives_for_symbol(self, fontname, sym):
- return self._size_alternatives.get(sym, [(fontname, sym)])
-
-
-class UnicodeFonts(TruetypeFonts):
- """
- An abstract base class for handling Unicode fonts.
-
- While some reasonably complete Unicode fonts (such as DejaVu) may
- work in some situations, the only Unicode font I'm aware of with a
- complete set of math symbols is STIX.
-
- This class will "fallback" on the Bakoma fonts when a required
- symbol can not be found in the font.
- """
-
- # Some glyphs are not present in the `cmr10` font, and must be brought in
- # from `cmsy10`. Map the Unicode indices of those glyphs to the indices at
- # which they are found in `cmsy10`.
- _cmr10_substitutions = {
- 0x00D7: 0x00A3, # Multiplication sign.
- 0x2212: 0x00A1, # Minus sign.
- }
-
- def __init__(self, *args, **kwargs):
- # This must come first so the backend's owner is set correctly
- fallback_rc = mpl.rcParams['mathtext.fallback']
- font_cls = {'stix': StixFonts,
- 'stixsans': StixSansFonts,
- 'cm': BakomaFonts
- }.get(fallback_rc)
- self._fallback_font = font_cls(*args, **kwargs) if font_cls else None
-
- super().__init__(*args, **kwargs)
- self.fontmap = {}
- for texfont in "cal rm tt it bf sf".split():
- prop = mpl.rcParams['mathtext.' + texfont]
- font = findfont(prop)
- self.fontmap[texfont] = font
- prop = FontProperties('cmex10')
- font = findfont(prop)
- self.fontmap['ex'] = font
-
- # include STIX sized alternatives for glyphs if fallback is STIX
- if isinstance(self._fallback_font, StixFonts):
- stixsizedaltfonts = {
- 0: 'STIXGeneral',
- 1: 'STIXSizeOneSym',
- 2: 'STIXSizeTwoSym',
- 3: 'STIXSizeThreeSym',
- 4: 'STIXSizeFourSym',
- 5: 'STIXSizeFiveSym'}
-
- for size, name in stixsizedaltfonts.items():
- fullpath = findfont(name)
- self.fontmap[size] = fullpath
- self.fontmap[name] = fullpath
-
- _slanted_symbols = set(r"\int \oint".split())
-
- def _map_virtual_font(self, fontname, font_class, uniindex):
- return fontname, uniindex
-
- def _get_glyph(self, fontname, font_class, sym):
- try:
- uniindex = get_unicode_index(sym)
- found_symbol = True
- except ValueError:
- uniindex = ord('?')
- found_symbol = False
- _log.warning("No TeX to Unicode mapping for {!a}.".format(sym))
-
- fontname, uniindex = self._map_virtual_font(
- fontname, font_class, uniindex)
-
- new_fontname = fontname
-
- # Only characters in the "Letter" class should be italicized in 'it'
- # mode. Greek capital letters should be Roman.
- if found_symbol:
- if fontname == 'it' and uniindex < 0x10000:
- char = chr(uniindex)
- if (unicodedata.category(char)[0] != "L"
- or unicodedata.name(char).startswith("GREEK CAPITAL")):
- new_fontname = 'rm'
-
- slanted = (new_fontname == 'it') or sym in self._slanted_symbols
- found_symbol = False
- font = self._get_font(new_fontname)
- if font is not None:
- if (uniindex in self._cmr10_substitutions
- and font.family_name == "cmr10"):
- font = get_font(
- cbook._get_data_path("fonts/ttf/cmsy10.ttf"))
- uniindex = self._cmr10_substitutions[uniindex]
- glyphindex = font.get_char_index(uniindex)
- if glyphindex != 0:
- found_symbol = True
-
- if not found_symbol:
- if self._fallback_font:
- if (fontname in ('it', 'regular')
- and isinstance(self._fallback_font, StixFonts)):
- fontname = 'rm'
-
- g = self._fallback_font._get_glyph(fontname, font_class, sym)
- family = g[0].family_name
- if family in list(BakomaFonts._fontmap.values()):
- family = "Computer Modern"
- _log.info("Substituting symbol %s from %s", sym, family)
- return g
-
- else:
- if (fontname in ('it', 'regular')
- and isinstance(self, StixFonts)):
- return self._get_glyph('rm', font_class, sym)
- _log.warning("Font {!r} does not have a glyph for {!a} "
- "[U+{:x}], substituting with a dummy "
- "symbol.".format(new_fontname, sym, uniindex))
- font = self._get_font('rm')
- uniindex = 0xA4 # currency char, for lack of anything better
- slanted = False
-
- return font, uniindex, slanted
-
- def get_sized_alternatives_for_symbol(self, fontname, sym):
- if self._fallback_font:
- return self._fallback_font.get_sized_alternatives_for_symbol(
- fontname, sym)
- return [(fontname, sym)]
-
-
-class DejaVuFonts(UnicodeFonts):
-
- def __init__(self, *args, **kwargs):
- # This must come first so the backend's owner is set correctly
- if isinstance(self, DejaVuSerifFonts):
- self._fallback_font = StixFonts(*args, **kwargs)
- else:
- self._fallback_font = StixSansFonts(*args, **kwargs)
- self.bakoma = BakomaFonts(*args, **kwargs)
- TruetypeFonts.__init__(self, *args, **kwargs)
- self.fontmap = {}
- # Include Stix sized alternatives for glyphs
- self._fontmap.update({
- 1: 'STIXSizeOneSym',
- 2: 'STIXSizeTwoSym',
- 3: 'STIXSizeThreeSym',
- 4: 'STIXSizeFourSym',
- 5: 'STIXSizeFiveSym',
- })
- for key, name in self._fontmap.items():
- fullpath = findfont(name)
- self.fontmap[key] = fullpath
- self.fontmap[name] = fullpath
-
- def _get_glyph(self, fontname, font_class, sym):
- # Override prime symbol to use Bakoma.
- if sym == r'\prime':
- return self.bakoma._get_glyph(fontname, font_class, sym)
- else:
- # check whether the glyph is available in the display font
- uniindex = get_unicode_index(sym)
- font = self._get_font('ex')
- if font is not None:
- glyphindex = font.get_char_index(uniindex)
- if glyphindex != 0:
- return super()._get_glyph('ex', font_class, sym)
- # otherwise return regular glyph
- return super()._get_glyph(fontname, font_class, sym)
-
-
-class DejaVuSerifFonts(DejaVuFonts):
- """
- A font handling class for the DejaVu Serif fonts
-
- If a glyph is not found it will fallback to Stix Serif
- """
- _fontmap = {
- 'rm': 'DejaVu Serif',
- 'it': 'DejaVu Serif:italic',
- 'bf': 'DejaVu Serif:weight=bold',
- 'sf': 'DejaVu Sans',
- 'tt': 'DejaVu Sans Mono',
- 'ex': 'DejaVu Serif Display',
- 0: 'DejaVu Serif',
- }
-
-
-class DejaVuSansFonts(DejaVuFonts):
- """
- A font handling class for the DejaVu Sans fonts
-
- If a glyph is not found it will fallback to Stix Sans
- """
- _fontmap = {
- 'rm': 'DejaVu Sans',
- 'it': 'DejaVu Sans:italic',
- 'bf': 'DejaVu Sans:weight=bold',
- 'sf': 'DejaVu Sans',
- 'tt': 'DejaVu Sans Mono',
- 'ex': 'DejaVu Sans Display',
- 0: 'DejaVu Sans',
- }
-
-
-class StixFonts(UnicodeFonts):
- """
- A font handling class for the STIX fonts.
-
- In addition to what UnicodeFonts provides, this class:
-
- - supports "virtual fonts" which are complete alpha numeric
- character sets with different font styles at special Unicode
- code points, such as "Blackboard".
-
- - handles sized alternative characters for the STIXSizeX fonts.
- """
- _fontmap = {
- 'rm': 'STIXGeneral',
- 'it': 'STIXGeneral:italic',
- 'bf': 'STIXGeneral:weight=bold',
- 'nonunirm': 'STIXNonUnicode',
- 'nonuniit': 'STIXNonUnicode:italic',
- 'nonunibf': 'STIXNonUnicode:weight=bold',
- 0: 'STIXGeneral',
- 1: 'STIXSizeOneSym',
- 2: 'STIXSizeTwoSym',
- 3: 'STIXSizeThreeSym',
- 4: 'STIXSizeFourSym',
- 5: 'STIXSizeFiveSym',
- }
- _fallback_font = False
- _sans = False
-
- def __init__(self, *args, **kwargs):
- TruetypeFonts.__init__(self, *args, **kwargs)
- self.fontmap = {}
- for key, name in self._fontmap.items():
- fullpath = findfont(name)
- self.fontmap[key] = fullpath
- self.fontmap[name] = fullpath
-
- def _map_virtual_font(self, fontname, font_class, uniindex):
- # Handle these "fonts" that are actually embedded in
- # other fonts.
- mapping = stix_virtual_fonts.get(fontname)
- if (self._sans and mapping is None
- and fontname not in ('regular', 'default')):
- mapping = stix_virtual_fonts['sf']
- doing_sans_conversion = True
- else:
- doing_sans_conversion = False
-
- if mapping is not None:
- if isinstance(mapping, dict):
- try:
- mapping = mapping[font_class]
- except KeyError:
- mapping = mapping['rm']
-
- # Binary search for the source glyph
- lo = 0
- hi = len(mapping)
- while lo < hi:
- mid = (lo+hi)//2
- range = mapping[mid]
- if uniindex < range[0]:
- hi = mid
- elif uniindex <= range[1]:
- break
- else:
- lo = mid + 1
-
- if range[0] <= uniindex <= range[1]:
- uniindex = uniindex - range[0] + range[3]
- fontname = range[2]
- elif not doing_sans_conversion:
- # This will generate a dummy character
- uniindex = 0x1
- fontname = mpl.rcParams['mathtext.default']
-
- # Fix some incorrect glyphs.
- if fontname in ('rm', 'it'):
- uniindex = stix_glyph_fixes.get(uniindex, uniindex)
-
- # Handle private use area glyphs
- if fontname in ('it', 'rm', 'bf') and 0xe000 <= uniindex <= 0xf8ff:
- fontname = 'nonuni' + fontname
-
- return fontname, uniindex
-
- @functools.lru_cache()
- def get_sized_alternatives_for_symbol(self, fontname, sym):
- fixes = {
- '\\{': '{', '\\}': '}', '\\[': '[', '\\]': ']',
- '<': '\N{MATHEMATICAL LEFT ANGLE BRACKET}',
- '>': '\N{MATHEMATICAL RIGHT ANGLE BRACKET}',
- }
- sym = fixes.get(sym, sym)
- try:
- uniindex = get_unicode_index(sym)
- except ValueError:
- return [(fontname, sym)]
- alternatives = [(i, chr(uniindex)) for i in range(6)
- if self._get_font(i).get_char_index(uniindex) != 0]
- # The largest size of the radical symbol in STIX has incorrect
- # metrics that cause it to be disconnected from the stem.
- if sym == r'\__sqrt__':
- alternatives = alternatives[:-1]
- return alternatives
-
-
-class StixSansFonts(StixFonts):
- """
- A font handling class for the STIX fonts (that uses sans-serif
- characters by default).
- """
- _sans = True
-
-
-##############################################################################
-# TeX-LIKE BOX MODEL
-
-# The following is based directly on the document 'woven' from the
-# TeX82 source code. This information is also available in printed
-# form:
-#
-# Knuth, Donald E.. 1986. Computers and Typesetting, Volume B:
-# TeX: The Program. Addison-Wesley Professional.
-#
-# The most relevant "chapters" are:
-# Data structures for boxes and their friends
-# Shipping pages out (ship())
-# Packaging (hpack() and vpack())
-# Data structures for math mode
-# Subroutines for math mode
-# Typesetting math formulas
-#
-# Many of the docstrings below refer to a numbered "node" in that
-# book, e.g., node123
-#
-# Note that (as TeX) y increases downward, unlike many other parts of
-# matplotlib.
-
-# How much text shrinks when going to the next-smallest level.
-SHRINK_FACTOR = 0.7
-# The number of different sizes of chars to use, beyond which they will not
-# get any smaller
-NUM_SIZE_LEVELS = 6
-
-
-class FontConstantsBase:
- """
- A set of constants that controls how certain things, such as sub-
- and superscripts are laid out. These are all metrics that can't
- be reliably retrieved from the font metrics in the font itself.
- """
- # Percentage of x-height of additional horiz. space after sub/superscripts
- script_space = 0.05
-
- # Percentage of x-height that sub/superscripts drop below the baseline
- subdrop = 0.4
-
- # Percentage of x-height that superscripts are raised from the baseline
- sup1 = 0.7
-
- # Percentage of x-height that subscripts drop below the baseline
- sub1 = 0.3
-
- # Percentage of x-height that subscripts drop below the baseline when a
- # superscript is present
- sub2 = 0.5
-
- # Percentage of x-height that sub/superscripts are offset relative to the
- # nucleus edge for non-slanted nuclei
- delta = 0.025
-
- # Additional percentage of last character height above 2/3 of the
- # x-height that superscripts are offset relative to the subscript
- # for slanted nuclei
- delta_slanted = 0.2
-
- # Percentage of x-height that superscripts and subscripts are offset for
- # integrals
- delta_integral = 0.1
-
-
-class ComputerModernFontConstants(FontConstantsBase):
- script_space = 0.075
- subdrop = 0.2
- sup1 = 0.45
- sub1 = 0.2
- sub2 = 0.3
- delta = 0.075
- delta_slanted = 0.3
- delta_integral = 0.3
-
-
-class STIXFontConstants(FontConstantsBase):
- script_space = 0.1
- sup1 = 0.8
- sub2 = 0.6
- delta = 0.05
- delta_slanted = 0.3
- delta_integral = 0.3
-
-
-class STIXSansFontConstants(FontConstantsBase):
- script_space = 0.05
- sup1 = 0.8
- delta_slanted = 0.6
- delta_integral = 0.3
-
-
-class DejaVuSerifFontConstants(FontConstantsBase):
- pass
-
-
-class DejaVuSansFontConstants(FontConstantsBase):
- pass
-
-
-# Maps font family names to the FontConstantBase subclass to use
-_font_constant_mapping = {
- 'DejaVu Sans': DejaVuSansFontConstants,
- 'DejaVu Sans Mono': DejaVuSansFontConstants,
- 'DejaVu Serif': DejaVuSerifFontConstants,
- 'cmb10': ComputerModernFontConstants,
- 'cmex10': ComputerModernFontConstants,
- 'cmmi10': ComputerModernFontConstants,
- 'cmr10': ComputerModernFontConstants,
- 'cmss10': ComputerModernFontConstants,
- 'cmsy10': ComputerModernFontConstants,
- 'cmtt10': ComputerModernFontConstants,
- 'STIXGeneral': STIXFontConstants,
- 'STIXNonUnicode': STIXFontConstants,
- 'STIXSizeFiveSym': STIXFontConstants,
- 'STIXSizeFourSym': STIXFontConstants,
- 'STIXSizeThreeSym': STIXFontConstants,
- 'STIXSizeTwoSym': STIXFontConstants,
- 'STIXSizeOneSym': STIXFontConstants,
- # Map the fonts we used to ship, just for good measure
- 'Bitstream Vera Sans': DejaVuSansFontConstants,
- 'Bitstream Vera': DejaVuSansFontConstants,
- }
-
-
-def _get_font_constant_set(state):
- constants = _font_constant_mapping.get(
- state.fontset._get_font(state.font).family_name, FontConstantsBase)
- # STIX sans isn't really its own fonts, just different code points
- # in the STIX fonts, so we have to detect this one separately.
- if (constants is STIXFontConstants and
- isinstance(state.fontset, StixSansFonts)):
- return STIXSansFontConstants
- return constants
-
-
-class Node:
- """A node in the TeX box model."""
-
- def __init__(self):
- self.size = 0
-
- def __repr__(self):
- return type(self).__name__
-
- def get_kerning(self, next):
- return 0.0
-
- def shrink(self):
- """
- Shrinks one level smaller. There are only three levels of
- sizes, after which things will no longer get smaller.
- """
- self.size += 1
-
- def render(self, output, x, y):
- """Render this node."""
-
-
-class Box(Node):
- """A node with a physical location."""
-
- def __init__(self, width, height, depth):
- super().__init__()
- self.width = width
- self.height = height
- self.depth = depth
-
- def shrink(self):
- super().shrink()
- if self.size < NUM_SIZE_LEVELS:
- self.width *= SHRINK_FACTOR
- self.height *= SHRINK_FACTOR
- self.depth *= SHRINK_FACTOR
-
- def render(self, output, x1, y1, x2, y2):
- pass
-
-
-class Vbox(Box):
- """A box with only height (zero width)."""
-
- def __init__(self, height, depth):
- super().__init__(0., height, depth)
-
-
-class Hbox(Box):
- """A box with only width (zero height and depth)."""
-
- def __init__(self, width):
- super().__init__(width, 0., 0.)
-
-
-class Char(Node):
- """
- A single character.
-
- Unlike TeX, the font information and metrics are stored with each `Char`
- to make it easier to lookup the font metrics when needed. Note that TeX
- boxes have a width, height, and depth, unlike Type1 and TrueType which use
- a full bounding box and an advance in the x-direction. The metrics must
- be converted to the TeX model, and the advance (if different from width)
- must be converted into a `Kern` node when the `Char` is added to its parent
- `Hlist`.
- """
-
- def __init__(self, c, state):
- super().__init__()
- self.c = c
- self.fontset = state.fontset
- self.font = state.font
- self.font_class = state.font_class
- self.fontsize = state.fontsize
- self.dpi = state.dpi
- # The real width, height and depth will be set during the
- # pack phase, after we know the real fontsize
- self._update_metrics()
-
- def __repr__(self):
- return '`%s`' % self.c
-
- def _update_metrics(self):
- metrics = self._metrics = self.fontset.get_metrics(
- self.font, self.font_class, self.c, self.fontsize, self.dpi)
- if self.c == ' ':
- self.width = metrics.advance
- else:
- self.width = metrics.width
- self.height = metrics.iceberg
- self.depth = -(metrics.iceberg - metrics.height)
-
- def is_slanted(self):
- return self._metrics.slanted
-
- def get_kerning(self, next):
- """
- Return the amount of kerning between this and the given character.
-
- This method is called when characters are strung together into `Hlist`
- to create `Kern` nodes.
- """
- advance = self._metrics.advance - self.width
- kern = 0.
- if isinstance(next, Char):
- kern = self.fontset.get_kern(
- self.font, self.font_class, self.c, self.fontsize,
- next.font, next.font_class, next.c, next.fontsize,
- self.dpi)
- return advance + kern
-
- def render(self, output, x, y):
- self.fontset.render_glyph(
- output, x, y,
- self.font, self.font_class, self.c, self.fontsize, self.dpi)
-
- def shrink(self):
- super().shrink()
- if self.size < NUM_SIZE_LEVELS:
- self.fontsize *= SHRINK_FACTOR
- self.width *= SHRINK_FACTOR
- self.height *= SHRINK_FACTOR
- self.depth *= SHRINK_FACTOR
-
-
-class Accent(Char):
- """
- The font metrics need to be dealt with differently for accents,
- since they are already offset correctly from the baseline in
- TrueType fonts.
- """
- def _update_metrics(self):
- metrics = self._metrics = self.fontset.get_metrics(
- self.font, self.font_class, self.c, self.fontsize, self.dpi)
- self.width = metrics.xmax - metrics.xmin
- self.height = metrics.ymax - metrics.ymin
- self.depth = 0
-
- def shrink(self):
- super().shrink()
- self._update_metrics()
-
- def render(self, output, x, y):
- self.fontset.render_glyph(
- output, x - self._metrics.xmin, y + self._metrics.ymin,
- self.font, self.font_class, self.c, self.fontsize, self.dpi)
-
-
-class List(Box):
- """A list of nodes (either horizontal or vertical)."""
-
- def __init__(self, elements):
- super().__init__(0., 0., 0.)
- self.shift_amount = 0. # An arbitrary offset
- self.children = elements # The child nodes of this list
- # The following parameters are set in the vpack and hpack functions
- self.glue_set = 0. # The glue setting of this list
- self.glue_sign = 0 # 0: normal, -1: shrinking, 1: stretching
- self.glue_order = 0 # The order of infinity (0 - 3) for the glue
-
- def __repr__(self):
- return '%s[%s]' % (
- super().__repr__(),
- self.width, self.height,
- self.depth, self.shift_amount,
- ', '.join([repr(x) for x in self.children]))
-
- def _set_glue(self, x, sign, totals, error_type):
- self.glue_order = o = next(
- # Highest order of glue used by the members of this list.
- (i for i in range(len(totals))[::-1] if totals[i] != 0), 0)
- self.glue_sign = sign
- if totals[o] != 0.:
- self.glue_set = x / totals[o]
- else:
- self.glue_sign = 0
- self.glue_ratio = 0.
- if o == 0:
- if len(self.children):
- _log.warning("%s %s: %r",
- error_type, type(self).__name__, self)
-
- def shrink(self):
- for child in self.children:
- child.shrink()
- super().shrink()
- if self.size < NUM_SIZE_LEVELS:
- self.shift_amount *= SHRINK_FACTOR
- self.glue_set *= SHRINK_FACTOR
-
-
-class Hlist(List):
- """A horizontal list of boxes."""
-
- def __init__(self, elements, w=0., m='additional', do_kern=True):
- super().__init__(elements)
- if do_kern:
- self.kern()
- self.hpack(w=w, m=m)
-
- def kern(self):
- """
- Insert `Kern` nodes between `Char` nodes to set kerning.
-
- The `Char` nodes themselves determine the amount of kerning they need
- (in `~Char.get_kerning`), and this function just creates the correct
- linked list.
- """
- new_children = []
- num_children = len(self.children)
- if num_children:
- for i in range(num_children):
- elem = self.children[i]
- if i < num_children - 1:
- next = self.children[i + 1]
- else:
- next = None
-
- new_children.append(elem)
- kerning_distance = elem.get_kerning(next)
- if kerning_distance != 0.:
- kern = Kern(kerning_distance)
- new_children.append(kern)
- self.children = new_children
-
- # This is a failed experiment to fake cross-font kerning.
-# def get_kerning(self, next):
-# if len(self.children) >= 2 and isinstance(self.children[-2], Char):
-# if isinstance(next, Char):
-# print "CASE A"
-# return self.children[-2].get_kerning(next)
-# elif (isinstance(next, Hlist) and len(next.children)
-# and isinstance(next.children[0], Char)):
-# print "CASE B"
-# result = self.children[-2].get_kerning(next.children[0])
-# print result
-# return result
-# return 0.0
-
- def hpack(self, w=0., m='additional'):
- r"""
- Compute the dimensions of the resulting boxes, and adjust the glue if
- one of those dimensions is pre-specified. The computed sizes normally
- enclose all of the material inside the new box; but some items may
- stick out if negative glue is used, if the box is overfull, or if a
- ``\vbox`` includes other boxes that have been shifted left.
-
- Parameters
- ----------
- w : float, default: 0
- A width.
- m : {'exactly', 'additional'}, default: 'additional'
- Whether to produce a box whose width is 'exactly' *w*; or a box
- with the natural width of the contents, plus *w* ('additional').
-
- Notes
- -----
- The defaults produce a box with the natural width of the contents.
- """
- # I don't know why these get reset in TeX. Shift_amount is pretty
- # much useless if we do.
- # self.shift_amount = 0.
- h = 0.
- d = 0.
- x = 0.
- total_stretch = [0.] * 4
- total_shrink = [0.] * 4
- for p in self.children:
- if isinstance(p, Char):
- x += p.width
- h = max(h, p.height)
- d = max(d, p.depth)
- elif isinstance(p, Box):
- x += p.width
- if not np.isinf(p.height) and not np.isinf(p.depth):
- s = getattr(p, 'shift_amount', 0.)
- h = max(h, p.height - s)
- d = max(d, p.depth + s)
- elif isinstance(p, Glue):
- glue_spec = p.glue_spec
- x += glue_spec.width
- total_stretch[glue_spec.stretch_order] += glue_spec.stretch
- total_shrink[glue_spec.shrink_order] += glue_spec.shrink
- elif isinstance(p, Kern):
- x += p.width
- self.height = h
- self.depth = d
-
- if m == 'additional':
- w += x
- self.width = w
- x = w - x
-
- if x == 0.:
- self.glue_sign = 0
- self.glue_order = 0
- self.glue_ratio = 0.
- return
- if x > 0.:
- self._set_glue(x, 1, total_stretch, "Overful")
- else:
- self._set_glue(x, -1, total_shrink, "Underful")
-
-
-class Vlist(List):
- """A vertical list of boxes."""
-
- def __init__(self, elements, h=0., m='additional'):
- super().__init__(elements)
- self.vpack(h=h, m=m)
-
- def vpack(self, h=0., m='additional', l=np.inf):
- """
- Compute the dimensions of the resulting boxes, and to adjust the glue
- if one of those dimensions is pre-specified.
-
- Parameters
- ----------
- h : float, default: 0
- A height.
- m : {'exactly', 'additional'}, default: 'additional'
- Whether to produce a box whose height is 'exactly' *h*; or a box
- with the natural height of the contents, plus *h* ('additional').
- l : float, default: np.inf
- The maximum height.
-
- Notes
- -----
- The defaults produce a box with the natural height of the contents.
- """
- # I don't know why these get reset in TeX. Shift_amount is pretty
- # much useless if we do.
- # self.shift_amount = 0.
- w = 0.
- d = 0.
- x = 0.
- total_stretch = [0.] * 4
- total_shrink = [0.] * 4
- for p in self.children:
- if isinstance(p, Box):
- x += d + p.height
- d = p.depth
- if not np.isinf(p.width):
- s = getattr(p, 'shift_amount', 0.)
- w = max(w, p.width + s)
- elif isinstance(p, Glue):
- x += d
- d = 0.
- glue_spec = p.glue_spec
- x += glue_spec.width
- total_stretch[glue_spec.stretch_order] += glue_spec.stretch
- total_shrink[glue_spec.shrink_order] += glue_spec.shrink
- elif isinstance(p, Kern):
- x += d + p.width
- d = 0.
- elif isinstance(p, Char):
- raise RuntimeError(
- "Internal mathtext error: Char node found in Vlist")
-
- self.width = w
- if d > l:
- x += d - l
- self.depth = l
- else:
- self.depth = d
-
- if m == 'additional':
- h += x
- self.height = h
- x = h - x
-
- if x == 0:
- self.glue_sign = 0
- self.glue_order = 0
- self.glue_ratio = 0.
- return
-
- if x > 0.:
- self._set_glue(x, 1, total_stretch, "Overful")
- else:
- self._set_glue(x, -1, total_shrink, "Underful")
-
-
-class Rule(Box):
- """
- A solid black rectangle.
-
- It has *width*, *depth*, and *height* fields just as in an `Hlist`.
- However, if any of these dimensions is inf, the actual value will be
- determined by running the rule up to the boundary of the innermost
- enclosing box. This is called a "running dimension". The width is never
- running in an `Hlist`; the height and depth are never running in a `Vlist`.
- """
-
- def __init__(self, width, height, depth, state):
- super().__init__(width, height, depth)
- self.fontset = state.fontset
-
- def render(self, output, x, y, w, h):
- self.fontset.render_rect_filled(output, x, y, x + w, y + h)
-
-
-class Hrule(Rule):
- """Convenience class to create a horizontal rule."""
-
- def __init__(self, state, thickness=None):
- if thickness is None:
- thickness = state.get_current_underline_thickness()
- height = depth = thickness * 0.5
- super().__init__(np.inf, height, depth, state)
-
-
-class Vrule(Rule):
- """Convenience class to create a vertical rule."""
-
- def __init__(self, state):
- thickness = state.get_current_underline_thickness()
- super().__init__(thickness, np.inf, np.inf, state)
-
-
-_GlueSpec = namedtuple(
- "_GlueSpec", "width stretch stretch_order shrink shrink_order")
-_GlueSpec._named = {
- 'fil': _GlueSpec(0., 1., 1, 0., 0),
- 'fill': _GlueSpec(0., 1., 2, 0., 0),
- 'filll': _GlueSpec(0., 1., 3, 0., 0),
- 'neg_fil': _GlueSpec(0., 0., 0, 1., 1),
- 'neg_fill': _GlueSpec(0., 0., 0, 1., 2),
- 'neg_filll': _GlueSpec(0., 0., 0, 1., 3),
- 'empty': _GlueSpec(0., 0., 0, 0., 0),
- 'ss': _GlueSpec(0., 1., 1, -1., 1),
-}
-
-
-class Glue(Node):
- """
- Most of the information in this object is stored in the underlying
- ``_GlueSpec`` class, which is shared between multiple glue objects.
- (This is a memory optimization which probably doesn't matter anymore, but
- it's easier to stick to what TeX does.)
- """
-
- def __init__(self, glue_type):
- super().__init__()
- if isinstance(glue_type, str):
- glue_spec = _GlueSpec._named[glue_type]
- elif isinstance(glue_type, _GlueSpec):
- glue_spec = glue_type
- else:
- raise ValueError("glue_type must be a glue spec name or instance")
- self.glue_spec = glue_spec
-
- def shrink(self):
- super().shrink()
- if self.size < NUM_SIZE_LEVELS:
- g = self.glue_spec
- self.glue_spec = g._replace(width=g.width * SHRINK_FACTOR)
-
-
-class HCentered(Hlist):
- """
- A convenience class to create an `Hlist` whose contents are
- centered within its enclosing box.
- """
-
- def __init__(self, elements):
- super().__init__([Glue('ss'), *elements, Glue('ss')], do_kern=False)
-
-
-class VCentered(Vlist):
- """
- A convenience class to create a `Vlist` whose contents are
- centered within its enclosing box.
- """
-
- def __init__(self, elements):
- super().__init__([Glue('ss'), *elements, Glue('ss')])
-
-
-class Kern(Node):
- """
- A `Kern` node has a width field to specify a (normally
- negative) amount of spacing. This spacing correction appears in
- horizontal lists between letters like A and V when the font
- designer said that it looks better to move them closer together or
- further apart. A kern node can also appear in a vertical list,
- when its *width* denotes additional spacing in the vertical
- direction.
- """
-
- height = 0
- depth = 0
-
- def __init__(self, width):
- super().__init__()
- self.width = width
-
- def __repr__(self):
- return "k%.02f" % self.width
-
- def shrink(self):
- super().shrink()
- if self.size < NUM_SIZE_LEVELS:
- self.width *= SHRINK_FACTOR
-
-
-class AutoHeightChar(Hlist):
- """
- A character as close to the given height and depth as possible.
-
- When using a font with multiple height versions of some characters (such as
- the BaKoMa fonts), the correct glyph will be selected, otherwise this will
- always just return a scaled version of the glyph.
- """
-
- def __init__(self, c, height, depth, state, always=False, factor=None):
- alternatives = state.fontset.get_sized_alternatives_for_symbol(
- state.font, c)
-
- xHeight = state.fontset.get_xheight(
- state.font, state.fontsize, state.dpi)
-
- state = state.copy()
- target_total = height + depth
- for fontname, sym in alternatives:
- state.font = fontname
- char = Char(sym, state)
- # Ensure that size 0 is chosen when the text is regular sized but
- # with descender glyphs by subtracting 0.2 * xHeight
- if char.height + char.depth >= target_total - 0.2 * xHeight:
- break
-
- shift = 0
- if state.font != 0 or len(alternatives) == 1:
- if factor is None:
- factor = target_total / (char.height + char.depth)
- state.fontsize *= factor
- char = Char(sym, state)
-
- shift = (depth - char.depth)
-
- super().__init__([char])
- self.shift_amount = shift
-
-
-class AutoWidthChar(Hlist):
- """
- A character as close to the given width as possible.
-
- When using a font with multiple width versions of some characters (such as
- the BaKoMa fonts), the correct glyph will be selected, otherwise this will
- always just return a scaled version of the glyph.
- """
-
- def __init__(self, c, width, state, always=False, char_class=Char):
- alternatives = state.fontset.get_sized_alternatives_for_symbol(
- state.font, c)
-
- state = state.copy()
- for fontname, sym in alternatives:
- state.font = fontname
- char = char_class(sym, state)
- if char.width >= width:
- break
-
- factor = width / char.width
- state.fontsize *= factor
- char = char_class(sym, state)
-
- super().__init__([char])
- self.width = char.width
-
-
-def ship(box, xy=(0, 0)):
- """
- Ship out *box* at offset *xy*, converting it to an `Output`.
-
- Since boxes can be inside of boxes inside of boxes, the main work of `ship`
- is done by two mutually recursive routines, `hlist_out` and `vlist_out`,
- which traverse the `Hlist` nodes and `Vlist` nodes inside of horizontal
- and vertical boxes. The global variables used in TeX to store state as it
- processes have become local variables here.
- """
- ox, oy = xy
- cur_v = 0.
- cur_h = 0.
- off_h = ox
- off_v = oy + box.height
- output = Output(box)
-
- def clamp(value):
- return -1e9 if value < -1e9 else +1e9 if value > +1e9 else value
-
- def hlist_out(box):
- nonlocal cur_v, cur_h, off_h, off_v
-
- cur_g = 0
- cur_glue = 0.
- glue_order = box.glue_order
- glue_sign = box.glue_sign
- base_line = cur_v
- left_edge = cur_h
-
- for p in box.children:
- if isinstance(p, Char):
- p.render(output, cur_h + off_h, cur_v + off_v)
- cur_h += p.width
- elif isinstance(p, Kern):
- cur_h += p.width
- elif isinstance(p, List):
- # node623
- if len(p.children) == 0:
- cur_h += p.width
- else:
- edge = cur_h
- cur_v = base_line + p.shift_amount
- if isinstance(p, Hlist):
- hlist_out(p)
- else:
- # p.vpack(box.height + box.depth, 'exactly')
- vlist_out(p)
- cur_h = edge + p.width
- cur_v = base_line
- elif isinstance(p, Box):
- # node624
- rule_height = p.height
- rule_depth = p.depth
- rule_width = p.width
- if np.isinf(rule_height):
- rule_height = box.height
- if np.isinf(rule_depth):
- rule_depth = box.depth
- if rule_height > 0 and rule_width > 0:
- cur_v = base_line + rule_depth
- p.render(output,
- cur_h + off_h, cur_v + off_v,
- rule_width, rule_height)
- cur_v = base_line
- cur_h += rule_width
- elif isinstance(p, Glue):
- # node625
- glue_spec = p.glue_spec
- rule_width = glue_spec.width - cur_g
- if glue_sign != 0: # normal
- if glue_sign == 1: # stretching
- if glue_spec.stretch_order == glue_order:
- cur_glue += glue_spec.stretch
- cur_g = round(clamp(box.glue_set * cur_glue))
- elif glue_spec.shrink_order == glue_order:
- cur_glue += glue_spec.shrink
- cur_g = round(clamp(box.glue_set * cur_glue))
- rule_width += cur_g
- cur_h += rule_width
-
- def vlist_out(box):
- nonlocal cur_v, cur_h, off_h, off_v
-
- cur_g = 0
- cur_glue = 0.
- glue_order = box.glue_order
- glue_sign = box.glue_sign
- left_edge = cur_h
- cur_v -= box.height
- top_edge = cur_v
-
- for p in box.children:
- if isinstance(p, Kern):
- cur_v += p.width
- elif isinstance(p, List):
- if len(p.children) == 0:
- cur_v += p.height + p.depth
- else:
- cur_v += p.height
- cur_h = left_edge + p.shift_amount
- save_v = cur_v
- p.width = box.width
- if isinstance(p, Hlist):
- hlist_out(p)
- else:
- vlist_out(p)
- cur_v = save_v + p.depth
- cur_h = left_edge
- elif isinstance(p, Box):
- rule_height = p.height
- rule_depth = p.depth
- rule_width = p.width
- if np.isinf(rule_width):
- rule_width = box.width
- rule_height += rule_depth
- if rule_height > 0 and rule_depth > 0:
- cur_v += rule_height
- p.render(output,
- cur_h + off_h, cur_v + off_v,
- rule_width, rule_height)
- elif isinstance(p, Glue):
- glue_spec = p.glue_spec
- rule_height = glue_spec.width - cur_g
- if glue_sign != 0: # normal
- if glue_sign == 1: # stretching
- if glue_spec.stretch_order == glue_order:
- cur_glue += glue_spec.stretch
- cur_g = round(clamp(box.glue_set * cur_glue))
- elif glue_spec.shrink_order == glue_order: # shrinking
- cur_glue += glue_spec.shrink
- cur_g = round(clamp(box.glue_set * cur_glue))
- rule_height += cur_g
- cur_v += rule_height
- elif isinstance(p, Char):
- raise RuntimeError(
- "Internal mathtext error: Char node found in vlist")
-
- hlist_out(box)
- return output
-
-
-##############################################################################
-# PARSER
-
-
-def Error(msg):
- """Helper class to raise parser errors."""
- def raise_error(s, loc, toks):
- raise ParseFatalException(s, loc, msg)
-
- return Empty().setParseAction(raise_error)
-
-
-class ParserState:
- """
- Parser state.
-
- States are pushed and popped from a stack as necessary, and the "current"
- state is always at the top of the stack.
-
- Upon entering and leaving a group { } or math/non-math, the stack is pushed
- and popped accordingly.
- """
-
- def __init__(self, fontset, font, font_class, fontsize, dpi):
- self.fontset = fontset
- self._font = font
- self.font_class = font_class
- self.fontsize = fontsize
- self.dpi = dpi
-
- def copy(self):
- return copy.copy(self)
-
- @property
- def font(self):
- return self._font
-
- @font.setter
- def font(self, name):
- if name in ('rm', 'it', 'bf'):
- self.font_class = name
- self._font = name
-
- def get_current_underline_thickness(self):
- """Return the underline thickness for this state."""
- return self.fontset.get_underline_thickness(
- self.font, self.fontsize, self.dpi)
-
-
-def cmd(expr, args):
- r"""
- Helper to define TeX commands.
-
- ``cmd("\cmd", args)`` is equivalent to
- ``"\cmd" - (args | Error("Expected \cmd{arg}{...}"))`` where the names in
- the error message are taken from element names in *args*. If *expr*
- already includes arguments (e.g. "\cmd{arg}{...}"), then they are stripped
- when constructing the parse element, but kept (and *expr* is used as is) in
- the error message.
- """
-
- def names(elt):
- if isinstance(elt, ParseExpression):
- for expr in elt.exprs:
- yield from names(expr)
- elif elt.resultsName:
- yield elt.resultsName
-
- csname = expr.split("{", 1)[0]
- err = (csname + "".join("{%s}" % name for name in names(args))
- if expr == csname else expr)
- return csname - (args | Error(f"Expected {err}"))
-
-
-class Parser:
- """
- A pyparsing-based parser for strings containing math expressions.
-
- Raw text may also appear outside of pairs of ``$``.
-
- The grammar is based directly on that in TeX, though it cuts a few corners.
- """
-
- class _MathStyle(enum.Enum):
- DISPLAYSTYLE = 0
- TEXTSTYLE = 1
- SCRIPTSTYLE = 2
- SCRIPTSCRIPTSTYLE = 3
-
- _binary_operators = set(
- '+ * - \N{MINUS SIGN}'
- r'''
- \pm \sqcap \rhd
- \mp \sqcup \unlhd
- \times \vee \unrhd
- \div \wedge \oplus
- \ast \setminus \ominus
- \star \wr \otimes
- \circ \diamond \oslash
- \bullet \bigtriangleup \odot
- \cdot \bigtriangledown \bigcirc
- \cap \triangleleft \dagger
- \cup \triangleright \ddagger
- \uplus \lhd \amalg
- \dotplus \dotminus'''.split())
-
- _relation_symbols = set(r'''
- = < > :
- \leq \geq \equiv \models
- \prec \succ \sim \perp
- \preceq \succeq \simeq \mid
- \ll \gg \asymp \parallel
- \subset \supset \approx \bowtie
- \subseteq \supseteq \cong \Join
- \sqsubset \sqsupset \neq \smile
- \sqsubseteq \sqsupseteq \doteq \frown
- \in \ni \propto \vdash
- \dashv \dots \doteqdot'''.split())
-
- _arrow_symbols = set(r'''
- \leftarrow \longleftarrow \uparrow
- \Leftarrow \Longleftarrow \Uparrow
- \rightarrow \longrightarrow \downarrow
- \Rightarrow \Longrightarrow \Downarrow
- \leftrightarrow \longleftrightarrow \updownarrow
- \Leftrightarrow \Longleftrightarrow \Updownarrow
- \mapsto \longmapsto \nearrow
- \hookleftarrow \hookrightarrow \searrow
- \leftharpoonup \rightharpoonup \swarrow
- \leftharpoondown \rightharpoondown \nwarrow
- \rightleftharpoons \leadsto'''.split())
-
- _spaced_symbols = _binary_operators | _relation_symbols | _arrow_symbols
-
- _punctuation_symbols = set(r', ; . ! \ldotp \cdotp'.split())
-
- _overunder_symbols = set(r'''
- \sum \prod \coprod \bigcap \bigcup \bigsqcup \bigvee
- \bigwedge \bigodot \bigotimes \bigoplus \biguplus
- '''.split())
-
- _overunder_functions = set("lim liminf limsup sup max min".split())
-
- _dropsub_symbols = set(r'''\int \oint'''.split())
-
- _fontnames = set("rm cal it tt sf bf default bb frak scr regular".split())
-
- _function_names = set("""
- arccos csc ker min arcsin deg lg Pr arctan det lim sec arg dim
- liminf sin cos exp limsup sinh cosh gcd ln sup cot hom log tan
- coth inf max tanh""".split())
-
- _ambi_delims = set(r"""
- | \| / \backslash \uparrow \downarrow \updownarrow \Uparrow
- \Downarrow \Updownarrow . \vert \Vert""".split())
- _left_delims = set(r"( [ \{ < \lfloor \langle \lceil".split())
- _right_delims = set(r") ] \} > \rfloor \rangle \rceil".split())
- _delims = _left_delims | _right_delims | _ambi_delims
-
- def __init__(self):
- p = types.SimpleNamespace()
-
- def set_names_and_parse_actions():
- for key, val in vars(p).items():
- if not key.startswith('_'):
- # Set names on everything -- very useful for debugging
- val.setName(key)
- # Set actions
- if hasattr(self, key):
- val.setParseAction(getattr(self, key))
-
- # Root definitions.
-
- # In TeX parlance, a csname is a control sequence name (a "\foo").
- def csnames(group, names):
- ends_with_alpha = []
- ends_with_nonalpha = []
- for name in names:
- if name[-1].isalpha():
- ends_with_alpha.append(name)
- else:
- ends_with_nonalpha.append(name)
- return Regex(r"\\(?P<{}>(?:{})(?![A-Za-z]){})".format(
- group,
- "|".join(map(re.escape, ends_with_alpha)),
- "".join(f"|{s}" for s in map(re.escape, ends_with_nonalpha)),
- ))
-
- p.float_literal = Regex(r"[-+]?([0-9]+\.?[0-9]*|\.[0-9]+)")
- p.space = oneOf(self._space_widths)("space")
-
- p.style_literal = oneOf(
- [str(e.value) for e in self._MathStyle])("style_literal")
-
- p.symbol = Regex(
- r"[a-zA-Z0-9 +\-*/<>=:,.;!\?&'@()\[\]|\U00000080-\U0001ffff]"
- r"|\\[%${}\[\]_|]"
- + r"|\\(?:{})(?![A-Za-z])".format(
- "|".join(map(re.escape, tex2uni)))
- )("sym").leaveWhitespace()
- p.unknown_symbol = Regex(r"\\[A-Za-z]*")("name")
-
- p.font = csnames("font", self._fontnames)
- p.start_group = (
- Optional(r"\math" + oneOf(self._fontnames)("font")) + "{")
- p.end_group = Literal("}")
-
- p.delim = oneOf(self._delims)
-
- set_names_and_parse_actions() # for root definitions.
-
- # Mutually recursive definitions. (Minimizing the number of Forward
- # elements is important for speed.)
- p.accent = Forward()
- p.auto_delim = Forward()
- p.binom = Forward()
- p.customspace = Forward()
- p.frac = Forward()
- p.dfrac = Forward()
- p.function = Forward()
- p.genfrac = Forward()
- p.group = Forward()
- p.operatorname = Forward()
- p.overline = Forward()
- p.overset = Forward()
- p.placeable = Forward()
- p.required_group = Forward()
- p.simple = Forward()
- p.optional_group = Forward()
- p.sqrt = Forward()
- p.subsuper = Forward()
- p.token = Forward()
- p.underset = Forward()
-
- set_names_and_parse_actions() # for mutually recursive definitions.
-
- p.customspace <<= cmd(r"\hspace", "{" + p.float_literal("space") + "}")
-
- p.accent <<= (
- csnames("accent", [*self._accent_map, *self._wide_accents])
- - p.placeable("sym"))
-
- p.function <<= csnames("name", self._function_names)
- p.operatorname <<= cmd(
- r"\operatorname",
- "{" + ZeroOrMore(p.simple | p.unknown_symbol)("name") + "}")
-
- p.group <<= p.start_group + ZeroOrMore(p.token)("group") + p.end_group
-
- p.optional_group <<= "{" + ZeroOrMore(p.token)("group") + "}"
- p.required_group <<= "{" + OneOrMore(p.token)("group") + "}"
-
- p.frac <<= cmd(
- r"\frac", p.required_group("num") + p.required_group("den"))
- p.dfrac <<= cmd(
- r"\dfrac", p.required_group("num") + p.required_group("den"))
- p.binom <<= cmd(
- r"\binom", p.required_group("num") + p.required_group("den"))
-
- p.genfrac <<= cmd(
- r"\genfrac",
- "{" + Optional(p.delim)("ldelim") + "}"
- + "{" + Optional(p.delim)("rdelim") + "}"
- + "{" + p.float_literal("rulesize") + "}"
- + "{" + Optional(p.style_literal)("style") + "}"
- + p.required_group("num")
- + p.required_group("den"))
-
- p.sqrt <<= cmd(
- r"\sqrt{value}",
- Optional("[" + OneOrMore(NotAny("]") + p.token)("root") + "]")
- + p.required_group("value"))
-
- p.overline <<= cmd(r"\overline", p.required_group("body"))
-
- p.overset <<= cmd(
- r"\overset",
- p.optional_group("annotation") + p.optional_group("body"))
- p.underset <<= cmd(
- r"\underset",
- p.optional_group("annotation") + p.optional_group("body"))
-
- p.placeable <<= (
- p.accent # Must be before symbol as all accents are symbols
- | p.symbol # Must be second to catch all named symbols and single
- # chars not in a group
- | p.function
- | p.operatorname
- | p.group
- | p.frac
- | p.dfrac
- | p.binom
- | p.genfrac
- | p.overset
- | p.underset
- | p.sqrt
- | p.overline
- )
-
- p.simple <<= (
- p.space
- | p.customspace
- | p.font
- | p.subsuper
- )
-
- p.subsuper <<= (
- (Optional(p.placeable)("nucleus")
- + OneOrMore(oneOf(["_", "^"]) - p.placeable)("subsuper")
- + Regex("'*")("apostrophes"))
- | Regex("'+")("apostrophes")
- | (p.placeable("nucleus") + Regex("'*")("apostrophes"))
- )
-
- p.token <<= (
- p.simple
- | p.auto_delim
- | p.unknown_symbol # Must be last
- )
-
- p.auto_delim <<= (
- r"\left" - (p.delim("left") | Error("Expected a delimiter"))
- + ZeroOrMore(p.simple | p.auto_delim)("mid")
- + r"\right" - (p.delim("right") | Error("Expected a delimiter"))
- )
-
- # Leaf definitions.
- p.math = OneOrMore(p.token)
- p.math_string = QuotedString('$', '\\', unquoteResults=False)
- p.non_math = Regex(r"(?:(?:\\[$])|[^$])*").leaveWhitespace()
- p.main = (
- p.non_math + ZeroOrMore(p.math_string + p.non_math) + StringEnd()
- )
- set_names_and_parse_actions() # for leaf definitions.
-
- self._expression = p.main
- self._math_expression = p.math
-
- # To add space to nucleus operators after sub/superscripts
- self._in_subscript_or_superscript = False
-
- def parse(self, s, fonts_object, fontsize, dpi):
- """
- Parse expression *s* using the given *fonts_object* for
- output, at the given *fontsize* and *dpi*.
-
- Returns the parse tree of `Node` instances.
- """
- self._state_stack = [
- ParserState(fonts_object, 'default', 'rm', fontsize, dpi)]
- self._em_width_cache = {}
- try:
- result = self._expression.parseString(s)
- except ParseBaseException as err:
- # explain becomes a plain method on pyparsing 3 (err.explain(0)).
- raise ValueError("\n" + ParseException.explain(err, 0)) from None
- self._state_stack = None
- self._in_subscript_or_superscript = False
- # prevent operator spacing from leaking into a new expression
- self._em_width_cache = {}
- self._expression.resetCache()
- return result[0]
-
- def get_state(self):
- """Get the current `State` of the parser."""
- return self._state_stack[-1]
-
- def pop_state(self):
- """Pop a `State` off of the stack."""
- self._state_stack.pop()
-
- def push_state(self):
- """Push a new `State` onto the stack, copying the current state."""
- self._state_stack.append(self.get_state().copy())
-
- def main(self, s, loc, toks):
- return [Hlist(toks)]
-
- def math_string(self, s, loc, toks):
- return self._math_expression.parseString(toks[0][1:-1])
-
- def math(self, s, loc, toks):
- hlist = Hlist(toks)
- self.pop_state()
- return [hlist]
-
- def non_math(self, s, loc, toks):
- s = toks[0].replace(r'\$', '$')
- symbols = [Char(c, self.get_state()) for c in s]
- hlist = Hlist(symbols)
- # We're going into math now, so set font to 'it'
- self.push_state()
- self.get_state().font = mpl.rcParams['mathtext.default']
- return [hlist]
-
- float_literal = staticmethod(pyparsing_common.convertToFloat)
-
- def _make_space(self, percentage):
- # In TeX, an em (the unit usually used to measure horizontal lengths)
- # is not the width of the character 'm'; it is the same in different
- # font styles (e.g. roman or italic). Mathtext, however, uses 'm' in
- # the italic style so that horizontal spaces don't depend on the
- # current font style.
- state = self.get_state()
- key = (state.font, state.fontsize, state.dpi)
- width = self._em_width_cache.get(key)
- if width is None:
- metrics = state.fontset.get_metrics(
- 'it', mpl.rcParams['mathtext.default'], 'm',
- state.fontsize, state.dpi)
- width = metrics.advance
- self._em_width_cache[key] = width
- return Kern(width * percentage)
-
- _space_widths = {
- r'\,': 0.16667, # 3/18 em = 3 mu
- r'\thinspace': 0.16667, # 3/18 em = 3 mu
- r'\/': 0.16667, # 3/18 em = 3 mu
- r'\>': 0.22222, # 4/18 em = 4 mu
- r'\:': 0.22222, # 4/18 em = 4 mu
- r'\;': 0.27778, # 5/18 em = 5 mu
- r'\ ': 0.33333, # 6/18 em = 6 mu
- r'~': 0.33333, # 6/18 em = 6 mu, nonbreakable
- r'\enspace': 0.5, # 9/18 em = 9 mu
- r'\quad': 1, # 1 em = 18 mu
- r'\qquad': 2, # 2 em = 36 mu
- r'\!': -0.16667, # -3/18 em = -3 mu
- }
-
- def space(self, s, loc, toks):
- num = self._space_widths[toks["space"]]
- box = self._make_space(num)
- return [box]
-
- def customspace(self, s, loc, toks):
- return [self._make_space(toks["space"])]
-
- def symbol(self, s, loc, toks):
- c = toks["sym"]
- if c == "-":
- # "U+2212 minus sign is the preferred representation of the unary
- # and binary minus sign rather than the ASCII-derived U+002D
- # hyphen-minus, because minus sign is unambiguous and because it
- # is rendered with a more desirable length, usually longer than a
- # hyphen." (https://www.unicode.org/reports/tr25/)
- c = "\N{MINUS SIGN}"
- try:
- char = Char(c, self.get_state())
- except ValueError as err:
- raise ParseFatalException(s, loc,
- "Unknown symbol: %s" % c) from err
-
- if c in self._spaced_symbols:
- # iterate until we find previous character, needed for cases
- # such as ${ -2}$, $ -2$, or $ -2$.
- prev_char = next((c for c in s[:loc][::-1] if c != ' '), '')
- # Binary operators at start of string should not be spaced
- if (c in self._binary_operators and
- (len(s[:loc].split()) == 0 or prev_char == '{' or
- prev_char in self._left_delims)):
- return [char]
- else:
- return [Hlist([self._make_space(0.2),
- char,
- self._make_space(0.2)],
- do_kern=True)]
- elif c in self._punctuation_symbols:
- prev_char = next((c for c in s[:loc][::-1] if c != ' '), '')
- next_char = next((c for c in s[loc + 1:] if c != ' '), '')
-
- # Do not space commas between brackets
- if c == ',':
- if prev_char == '{' and next_char == '}':
- return [char]
-
- # Do not space dots as decimal separators
- if c == '.' and prev_char.isdigit() and next_char.isdigit():
- return [char]
- else:
- return [Hlist([char, self._make_space(0.2)], do_kern=True)]
- return [char]
-
- def unknown_symbol(self, s, loc, toks):
- raise ParseFatalException(s, loc, f"Unknown symbol: {toks['name']}")
-
- _accent_map = {
- r'hat': r'\circumflexaccent',
- r'breve': r'\combiningbreve',
- r'bar': r'\combiningoverline',
- r'grave': r'\combininggraveaccent',
- r'acute': r'\combiningacuteaccent',
- r'tilde': r'\combiningtilde',
- r'dot': r'\combiningdotabove',
- r'ddot': r'\combiningdiaeresis',
- r'dddot': r'\combiningthreedotsabove',
- r'ddddot': r'\combiningfourdotsabove',
- r'vec': r'\combiningrightarrowabove',
- r'"': r'\combiningdiaeresis',
- r"`": r'\combininggraveaccent',
- r"'": r'\combiningacuteaccent',
- r'~': r'\combiningtilde',
- r'.': r'\combiningdotabove',
- r'^': r'\circumflexaccent',
- r'overrightarrow': r'\rightarrow',
- r'overleftarrow': r'\leftarrow',
- r'mathring': r'\circ',
- }
-
- _wide_accents = set(r"widehat widetilde widebar".split())
-
- def accent(self, s, loc, toks):
- state = self.get_state()
- thickness = state.get_current_underline_thickness()
- accent = toks["accent"]
- sym = toks["sym"]
- if accent in self._wide_accents:
- accent_box = AutoWidthChar(
- '\\' + accent, sym.width, state, char_class=Accent)
- else:
- accent_box = Accent(self._accent_map[accent], state)
- if accent == 'mathring':
- accent_box.shrink()
- accent_box.shrink()
- centered = HCentered([Hbox(sym.width / 4.0), accent_box])
- centered.hpack(sym.width, 'exactly')
- return Vlist([
- centered,
- Vbox(0., thickness * 2.0),
- Hlist([sym])
- ])
-
- def function(self, s, loc, toks):
- hlist = self.operatorname(s, loc, toks)
- hlist.function_name = toks["name"]
- return hlist
-
- def operatorname(self, s, loc, toks):
- self.push_state()
- state = self.get_state()
- state.font = 'rm'
- hlist_list = []
- # Change the font of Chars, but leave Kerns alone
- name = toks["name"]
- for c in name:
- if isinstance(c, Char):
- c.font = 'rm'
- c._update_metrics()
- hlist_list.append(c)
- elif isinstance(c, str):
- hlist_list.append(Char(c, state))
- else:
- hlist_list.append(c)
- next_char_loc = loc + len(name) + 1
- if isinstance(name, ParseResults):
- next_char_loc += len('operatorname{}')
- next_char = next((c for c in s[next_char_loc:] if c != ' '), '')
- delimiters = self._delims | {'^', '_'}
- if (next_char not in delimiters and
- name not in self._overunder_functions):
- # Add thin space except when followed by parenthesis, bracket, etc.
- hlist_list += [self._make_space(self._space_widths[r'\,'])]
- self.pop_state()
- # if followed by a super/subscript, set flag to true
- # This flag tells subsuper to add space after this operator
- if next_char in {'^', '_'}:
- self._in_subscript_or_superscript = True
- else:
- self._in_subscript_or_superscript = False
-
- return Hlist(hlist_list)
-
- def start_group(self, s, loc, toks):
- self.push_state()
- # Deal with LaTeX-style font tokens
- if toks.get("font"):
- self.get_state().font = toks.get("font")
- return []
-
- def group(self, s, loc, toks):
- grp = Hlist(toks.get("group", []))
- return [grp]
-
- def required_group(self, s, loc, toks):
- return Hlist(toks.get("group", []))
-
- optional_group = required_group
-
- def end_group(self, s, loc, toks):
- self.pop_state()
- return []
-
- def font(self, s, loc, toks):
- self.get_state().font = toks["font"]
- return []
-
- def is_overunder(self, nucleus):
- if isinstance(nucleus, Char):
- return nucleus.c in self._overunder_symbols
- elif isinstance(nucleus, Hlist) and hasattr(nucleus, 'function_name'):
- return nucleus.function_name in self._overunder_functions
- return False
-
- def is_dropsub(self, nucleus):
- if isinstance(nucleus, Char):
- return nucleus.c in self._dropsub_symbols
- return False
-
- def is_slanted(self, nucleus):
- if isinstance(nucleus, Char):
- return nucleus.is_slanted()
- return False
-
- def is_between_brackets(self, s, loc):
- return False
-
- def subsuper(self, s, loc, toks):
- nucleus = toks.get("nucleus", Hbox(0))
- subsuper = toks.get("subsuper", [])
- napostrophes = len(toks.get("apostrophes", []))
-
- if not subsuper and not napostrophes:
- return nucleus
-
- sub = super = None
- while subsuper:
- op, arg, *subsuper = subsuper
- if op == '_':
- if sub is not None:
- raise ParseFatalException("Double subscript")
- sub = arg
- else:
- if super is not None:
- raise ParseFatalException("Double superscript")
- super = arg
-
- state = self.get_state()
- rule_thickness = state.fontset.get_underline_thickness(
- state.font, state.fontsize, state.dpi)
- xHeight = state.fontset.get_xheight(
- state.font, state.fontsize, state.dpi)
-
- if napostrophes:
- if super is None:
- super = Hlist([])
- for i in range(napostrophes):
- super.children.extend(self.symbol(s, loc, {"sym": "\\prime"}))
- # kern() and hpack() needed to get the metrics right after
- # extending
- super.kern()
- super.hpack()
-
- # Handle over/under symbols, such as sum or prod
- if self.is_overunder(nucleus):
- vlist = []
- shift = 0.
- width = nucleus.width
- if super is not None:
- super.shrink()
- width = max(width, super.width)
- if sub is not None:
- sub.shrink()
- width = max(width, sub.width)
-
- vgap = rule_thickness * 3.0
- if super is not None:
- hlist = HCentered([super])
- hlist.hpack(width, 'exactly')
- vlist.extend([hlist, Vbox(0, vgap)])
- hlist = HCentered([nucleus])
- hlist.hpack(width, 'exactly')
- vlist.append(hlist)
- if sub is not None:
- hlist = HCentered([sub])
- hlist.hpack(width, 'exactly')
- vlist.extend([Vbox(0, vgap), hlist])
- shift = hlist.height + vgap + nucleus.depth
- vlist = Vlist(vlist)
- vlist.shift_amount = shift
- result = Hlist([vlist])
- return [result]
-
- # We remove kerning on the last character for consistency (otherwise
- # it will compute kerning based on non-shrunk characters and may put
- # them too close together when superscripted)
- # We change the width of the last character to match the advance to
- # consider some fonts with weird metrics: e.g. stix's f has a width of
- # 7.75 and a kerning of -4.0 for an advance of 3.72, and we want to put
- # the superscript at the advance
- last_char = nucleus
- if isinstance(nucleus, Hlist):
- new_children = nucleus.children
- if len(new_children):
- # remove last kern
- if (isinstance(new_children[-1], Kern) and
- hasattr(new_children[-2], '_metrics')):
- new_children = new_children[:-1]
- last_char = new_children[-1]
- if hasattr(last_char, '_metrics'):
- last_char.width = last_char._metrics.advance
- # create new Hlist without kerning
- nucleus = Hlist(new_children, do_kern=False)
- else:
- if isinstance(nucleus, Char):
- last_char.width = last_char._metrics.advance
- nucleus = Hlist([nucleus])
-
- # Handle regular sub/superscripts
- constants = _get_font_constant_set(state)
- lc_height = last_char.height
- lc_baseline = 0
- if self.is_dropsub(last_char):
- lc_baseline = last_char.depth
-
- # Compute kerning for sub and super
- superkern = constants.delta * xHeight
- subkern = constants.delta * xHeight
- if self.is_slanted(last_char):
- superkern += constants.delta * xHeight
- superkern += (constants.delta_slanted *
- (lc_height - xHeight * 2. / 3.))
- if self.is_dropsub(last_char):
- subkern = (3 * constants.delta -
- constants.delta_integral) * lc_height
- superkern = (3 * constants.delta +
- constants.delta_integral) * lc_height
- else:
- subkern = 0
-
- if super is None:
- # node757
- x = Hlist([Kern(subkern), sub])
- x.shrink()
- if self.is_dropsub(last_char):
- shift_down = lc_baseline + constants.subdrop * xHeight
- else:
- shift_down = constants.sub1 * xHeight
- x.shift_amount = shift_down
- else:
- x = Hlist([Kern(superkern), super])
- x.shrink()
- if self.is_dropsub(last_char):
- shift_up = lc_height - constants.subdrop * xHeight
- else:
- shift_up = constants.sup1 * xHeight
- if sub is None:
- x.shift_amount = -shift_up
- else: # Both sub and superscript
- y = Hlist([Kern(subkern), sub])
- y.shrink()
- if self.is_dropsub(last_char):
- shift_down = lc_baseline + constants.subdrop * xHeight
- else:
- shift_down = constants.sub2 * xHeight
- # If sub and superscript collide, move super up
- clr = (2.0 * rule_thickness -
- ((shift_up - x.depth) - (y.height - shift_down)))
- if clr > 0.:
- shift_up += clr
- x = Vlist([
- x,
- Kern((shift_up - x.depth) - (y.height - shift_down)),
- y])
- x.shift_amount = shift_down
-
- if not self.is_dropsub(last_char):
- x.width += constants.script_space * xHeight
-
- # Do we need to add a space after the nucleus?
- # To find out, check the flag set by operatorname
- spaced_nucleus = [nucleus, x]
- if self._in_subscript_or_superscript:
- spaced_nucleus += [self._make_space(self._space_widths[r'\,'])]
- self._in_subscript_or_superscript = False
-
- result = Hlist(spaced_nucleus)
- return [result]
-
- def _genfrac(self, ldelim, rdelim, rule, style, num, den):
- state = self.get_state()
- thickness = state.get_current_underline_thickness()
-
- for _ in range(style.value):
- num.shrink()
- den.shrink()
- cnum = HCentered([num])
- cden = HCentered([den])
- width = max(num.width, den.width)
- cnum.hpack(width, 'exactly')
- cden.hpack(width, 'exactly')
- vlist = Vlist([cnum, # numerator
- Vbox(0, thickness * 2.0), # space
- Hrule(state, rule), # rule
- Vbox(0, thickness * 2.0), # space
- cden # denominator
- ])
-
- # Shift so the fraction line sits in the middle of the
- # equals sign
- metrics = state.fontset.get_metrics(
- state.font, mpl.rcParams['mathtext.default'],
- '=', state.fontsize, state.dpi)
- shift = (cden.height -
- ((metrics.ymax + metrics.ymin) / 2 -
- thickness * 3.0))
- vlist.shift_amount = shift
-
- result = [Hlist([vlist, Hbox(thickness * 2.)])]
- if ldelim or rdelim:
- if ldelim == '':
- ldelim = '.'
- if rdelim == '':
- rdelim = '.'
- return self._auto_sized_delimiter(ldelim, result, rdelim)
- return result
-
- def style_literal(self, s, loc, toks):
- return self._MathStyle(int(toks["style_literal"]))
-
- def genfrac(self, s, loc, toks):
- return self._genfrac(
- toks.get("ldelim", ""), toks.get("rdelim", ""),
- toks["rulesize"], toks.get("style", self._MathStyle.TEXTSTYLE),
- toks["num"], toks["den"])
-
- def frac(self, s, loc, toks):
- return self._genfrac(
- "", "", self.get_state().get_current_underline_thickness(),
- self._MathStyle.TEXTSTYLE, toks["num"], toks["den"])
-
- def dfrac(self, s, loc, toks):
- return self._genfrac(
- "", "", self.get_state().get_current_underline_thickness(),
- self._MathStyle.DISPLAYSTYLE, toks["num"], toks["den"])
-
- def binom(self, s, loc, toks):
- return self._genfrac(
- "(", ")", 0,
- self._MathStyle.TEXTSTYLE, toks["num"], toks["den"])
-
- def _genset(self, s, loc, toks):
- annotation = toks["annotation"]
- body = toks["body"]
- thickness = self.get_state().get_current_underline_thickness()
-
- annotation.shrink()
- cannotation = HCentered([annotation])
- cbody = HCentered([body])
- width = max(cannotation.width, cbody.width)
- cannotation.hpack(width, 'exactly')
- cbody.hpack(width, 'exactly')
-
- vgap = thickness * 3
- if s[loc + 1] == "u": # \underset
- vlist = Vlist([cbody, # body
- Vbox(0, vgap), # space
- cannotation # annotation
- ])
- # Shift so the body sits in the same vertical position
- vlist.shift_amount = cbody.depth + cannotation.height + vgap
- else: # \overset
- vlist = Vlist([cannotation, # annotation
- Vbox(0, vgap), # space
- cbody # body
- ])
-
- # To add horizontal gap between symbols: wrap the Vlist into
- # an Hlist and extend it with an Hbox(0, horizontal_gap)
- return vlist
-
- overset = underset = _genset
-
- def sqrt(self, s, loc, toks):
- root = toks.get("root")
- body = toks["value"]
- state = self.get_state()
- thickness = state.get_current_underline_thickness()
-
- # Determine the height of the body, and add a little extra to
- # the height so it doesn't seem cramped
- height = body.height - body.shift_amount + thickness * 5.0
- depth = body.depth + body.shift_amount
- check = AutoHeightChar(r'\__sqrt__', height, depth, state, always=True)
- height = check.height - check.shift_amount
- depth = check.depth + check.shift_amount
-
- # Put a little extra space to the left and right of the body
- padded_body = Hlist([Hbox(2 * thickness), body, Hbox(2 * thickness)])
- rightside = Vlist([Hrule(state), Glue('fill'), padded_body])
- # Stretch the glue between the hrule and the body
- rightside.vpack(height + (state.fontsize * state.dpi) / (100.0 * 12.0),
- 'exactly', depth)
-
- # Add the root and shift it upward so it is above the tick.
- # The value of 0.6 is a hard-coded hack ;)
- if not root:
- root = Box(check.width * 0.5, 0., 0.)
- else:
- root = Hlist(root)
- root.shrink()
- root.shrink()
-
- root_vlist = Vlist([Hlist([root])])
- root_vlist.shift_amount = -height * 0.6
-
- hlist = Hlist([root_vlist, # Root
- # Negative kerning to put root over tick
- Kern(-check.width * 0.5),
- check, # Check
- rightside]) # Body
- return [hlist]
-
- def overline(self, s, loc, toks):
- body = toks["body"]
-
- state = self.get_state()
- thickness = state.get_current_underline_thickness()
-
- height = body.height - body.shift_amount + thickness * 3.0
- depth = body.depth + body.shift_amount
-
- # Place overline above body
- rightside = Vlist([Hrule(state), Glue('fill'), Hlist([body])])
-
- # Stretch the glue between the hrule and the body
- rightside.vpack(height + (state.fontsize * state.dpi) / (100.0 * 12.0),
- 'exactly', depth)
-
- hlist = Hlist([rightside])
- return [hlist]
-
- def _auto_sized_delimiter(self, front, middle, back):
- state = self.get_state()
- if len(middle):
- height = max(x.height for x in middle)
- depth = max(x.depth for x in middle)
- factor = None
- else:
- height = 0
- depth = 0
- factor = 1.0
- parts = []
- # \left. and \right. aren't supposed to produce any symbols
- if front != '.':
- parts.append(
- AutoHeightChar(front, height, depth, state, factor=factor))
- parts.extend(middle)
- if back != '.':
- parts.append(
- AutoHeightChar(back, height, depth, state, factor=factor))
- hlist = Hlist(parts)
- return hlist
-
- def auto_delim(self, s, loc, toks):
- return self._auto_sized_delimiter(
- toks["left"],
- # if "mid" in toks ... can be removed when requiring pyparsing 3.
- toks["mid"].asList() if "mid" in toks else [],
- toks["right"])
diff --git a/spaces/dcq/freegpt-webui/g4f/Provider/Providers/helpers/theb.py b/spaces/dcq/freegpt-webui/g4f/Provider/Providers/helpers/theb.py
deleted file mode 100644
index 71cfd23ff34768092e4dbe3ff6b719a946dceebb..0000000000000000000000000000000000000000
--- a/spaces/dcq/freegpt-webui/g4f/Provider/Providers/helpers/theb.py
+++ /dev/null
@@ -1,48 +0,0 @@
-import json
-import sys
-from re import findall
-from curl_cffi import requests
-
-config = json.loads(sys.argv[1])
-prompt = config['messages'][-1]['content']
-
-headers = {
- 'authority': 'chatbot.theb.ai',
- 'accept': 'application/json, text/plain, */*',
- 'accept-language': 'en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3',
- 'content-type': 'application/json',
- 'origin': 'https://chatbot.theb.ai',
- 'referer': 'https://chatbot.theb.ai/',
- 'sec-ch-ua': '"Google Chrome";v="113", "Chromium";v="113", "Not-A.Brand";v="24"',
- 'sec-ch-ua-mobile': '?0',
- 'sec-ch-ua-platform': '"macOS"',
- 'sec-fetch-dest': 'empty',
- 'sec-fetch-mode': 'cors',
- 'sec-fetch-site': 'same-origin',
- 'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36',
-}
-
-json_data = {
- 'prompt': prompt,
- 'options': {}
-}
-
-def format(chunk):
- try:
- completion_chunk = findall(r'content":"(.*)"},"fin', chunk.decode())[0]
- print(completion_chunk, flush=True, end='')
-
- except Exception as e:
- print(f'[ERROR] an error occured, retrying... | [[{chunk.decode()}]]', flush=True)
- return
-
-while True:
- try:
- response = requests.post('https://chatbot.theb.ai/api/chat-process',
- headers=headers, json=json_data, content_callback=format, impersonate='chrome110')
-
- exit(0)
-
- except Exception as e:
- print('[ERROR] an error occured, retrying... |', e, flush=True)
- continue
\ No newline at end of file
diff --git a/spaces/declare-lab/tango/diffusers/src/diffusers/pipelines/stable_diffusion/__init__.py b/spaces/declare-lab/tango/diffusers/src/diffusers/pipelines/stable_diffusion/__init__.py
deleted file mode 100644
index 6bc2b58b5feffd53a522594406ab5354f5d57927..0000000000000000000000000000000000000000
--- a/spaces/declare-lab/tango/diffusers/src/diffusers/pipelines/stable_diffusion/__init__.py
+++ /dev/null
@@ -1,134 +0,0 @@
-from dataclasses import dataclass
-from typing import List, Optional, Union
-
-import numpy as np
-import PIL
-from PIL import Image
-
-from ...utils import (
- BaseOutput,
- OptionalDependencyNotAvailable,
- is_flax_available,
- is_k_diffusion_available,
- is_k_diffusion_version,
- is_onnx_available,
- is_torch_available,
- is_transformers_available,
- is_transformers_version,
-)
-
-
-@dataclass
-class StableDiffusionPipelineOutput(BaseOutput):
- """
- Output class for Stable Diffusion pipelines.
-
- Args:
- images (`List[PIL.Image.Image]` or `np.ndarray`)
- List of denoised PIL images of length `batch_size` or numpy array of shape `(batch_size, height, width,
- num_channels)`. PIL images or numpy array present the denoised images of the diffusion pipeline.
- nsfw_content_detected (`List[bool]`)
- List of flags denoting whether the corresponding generated image likely represents "not-safe-for-work"
- (nsfw) content, or `None` if safety checking could not be performed.
- """
-
- images: Union[List[PIL.Image.Image], np.ndarray]
- nsfw_content_detected: Optional[List[bool]]
-
-
-try:
- if not (is_transformers_available() and is_torch_available()):
- raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
- from ...utils.dummy_torch_and_transformers_objects import * # noqa F403
-else:
- from .pipeline_cycle_diffusion import CycleDiffusionPipeline
- from .pipeline_stable_diffusion import StableDiffusionPipeline
- from .pipeline_stable_diffusion_attend_and_excite import StableDiffusionAttendAndExcitePipeline
- from .pipeline_stable_diffusion_controlnet import StableDiffusionControlNetPipeline
- from .pipeline_stable_diffusion_img2img import StableDiffusionImg2ImgPipeline
- from .pipeline_stable_diffusion_inpaint import StableDiffusionInpaintPipeline
- from .pipeline_stable_diffusion_inpaint_legacy import StableDiffusionInpaintPipelineLegacy
- from .pipeline_stable_diffusion_instruct_pix2pix import StableDiffusionInstructPix2PixPipeline
- from .pipeline_stable_diffusion_latent_upscale import StableDiffusionLatentUpscalePipeline
- from .pipeline_stable_diffusion_model_editing import StableDiffusionModelEditingPipeline
- from .pipeline_stable_diffusion_panorama import StableDiffusionPanoramaPipeline
- from .pipeline_stable_diffusion_sag import StableDiffusionSAGPipeline
- from .pipeline_stable_diffusion_upscale import StableDiffusionUpscalePipeline
- from .pipeline_stable_unclip import StableUnCLIPPipeline
- from .pipeline_stable_unclip_img2img import StableUnCLIPImg2ImgPipeline
- from .safety_checker import StableDiffusionSafetyChecker
- from .stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
-
-try:
- if not (is_transformers_available() and is_torch_available() and is_transformers_version(">=", "4.25.0")):
- raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
- from ...utils.dummy_torch_and_transformers_objects import StableDiffusionImageVariationPipeline
-else:
- from .pipeline_stable_diffusion_image_variation import StableDiffusionImageVariationPipeline
-
-
-try:
- if not (is_transformers_available() and is_torch_available() and is_transformers_version(">=", "4.26.0")):
- raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
- from ...utils.dummy_torch_and_transformers_objects import (
- StableDiffusionDepth2ImgPipeline,
- StableDiffusionPix2PixZeroPipeline,
- )
-else:
- from .pipeline_stable_diffusion_depth2img import StableDiffusionDepth2ImgPipeline
- from .pipeline_stable_diffusion_pix2pix_zero import StableDiffusionPix2PixZeroPipeline
-
-
-try:
- if not (
- is_torch_available()
- and is_transformers_available()
- and is_k_diffusion_available()
- and is_k_diffusion_version(">=", "0.0.12")
- ):
- raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
- from ...utils.dummy_torch_and_transformers_and_k_diffusion_objects import * # noqa F403
-else:
- from .pipeline_stable_diffusion_k_diffusion import StableDiffusionKDiffusionPipeline
-
-try:
- if not (is_transformers_available() and is_onnx_available()):
- raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
- from ...utils.dummy_onnx_objects import * # noqa F403
-else:
- from .pipeline_onnx_stable_diffusion import OnnxStableDiffusionPipeline, StableDiffusionOnnxPipeline
- from .pipeline_onnx_stable_diffusion_img2img import OnnxStableDiffusionImg2ImgPipeline
- from .pipeline_onnx_stable_diffusion_inpaint import OnnxStableDiffusionInpaintPipeline
- from .pipeline_onnx_stable_diffusion_inpaint_legacy import OnnxStableDiffusionInpaintPipelineLegacy
- from .pipeline_onnx_stable_diffusion_upscale import OnnxStableDiffusionUpscalePipeline
-
-if is_transformers_available() and is_flax_available():
- import flax
-
- @flax.struct.dataclass
- class FlaxStableDiffusionPipelineOutput(BaseOutput):
- """
- Output class for Stable Diffusion pipelines.
-
- Args:
- images (`np.ndarray`)
- Array of shape `(batch_size, height, width, num_channels)` with images from the diffusion pipeline.
- nsfw_content_detected (`List[bool]`)
- List of flags denoting whether the corresponding generated image likely represents "not-safe-for-work"
- (nsfw) content.
- """
-
- images: np.ndarray
- nsfw_content_detected: List[bool]
-
- from ...schedulers.scheduling_pndm_flax import PNDMSchedulerState
- from .pipeline_flax_stable_diffusion import FlaxStableDiffusionPipeline
- from .pipeline_flax_stable_diffusion_controlnet import FlaxStableDiffusionControlNetPipeline
- from .pipeline_flax_stable_diffusion_img2img import FlaxStableDiffusionImg2ImgPipeline
- from .pipeline_flax_stable_diffusion_inpaint import FlaxStableDiffusionInpaintPipeline
- from .safety_checker_flax import FlaxStableDiffusionSafetyChecker
diff --git a/spaces/declare-lab/tango/diffusers/src/diffusers/schedulers/scheduling_karras_ve.py b/spaces/declare-lab/tango/diffusers/src/diffusers/schedulers/scheduling_karras_ve.py
deleted file mode 100644
index 87f6514a4e93e4a75bd6228ed852306b8c005c3d..0000000000000000000000000000000000000000
--- a/spaces/declare-lab/tango/diffusers/src/diffusers/schedulers/scheduling_karras_ve.py
+++ /dev/null
@@ -1,232 +0,0 @@
-# Copyright 2023 NVIDIA and The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-from dataclasses import dataclass
-from typing import Optional, Tuple, Union
-
-import numpy as np
-import torch
-
-from ..configuration_utils import ConfigMixin, register_to_config
-from ..utils import BaseOutput, randn_tensor
-from .scheduling_utils import SchedulerMixin
-
-
-@dataclass
-class KarrasVeOutput(BaseOutput):
- """
- Output class for the scheduler's step function output.
-
- Args:
- prev_sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images):
- Computed sample (x_{t-1}) of previous timestep. `prev_sample` should be used as next model input in the
- denoising loop.
- derivative (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images):
- Derivative of predicted original image sample (x_0).
- pred_original_sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images):
- The predicted denoised sample (x_{0}) based on the model output from the current timestep.
- `pred_original_sample` can be used to preview progress or for guidance.
- """
-
- prev_sample: torch.FloatTensor
- derivative: torch.FloatTensor
- pred_original_sample: Optional[torch.FloatTensor] = None
-
-
-class KarrasVeScheduler(SchedulerMixin, ConfigMixin):
- """
- Stochastic sampling from Karras et al. [1] tailored to the Variance-Expanding (VE) models [2]. Use Algorithm 2 and
- the VE column of Table 1 from [1] for reference.
-
- [1] Karras, Tero, et al. "Elucidating the Design Space of Diffusion-Based Generative Models."
- https://arxiv.org/abs/2206.00364 [2] Song, Yang, et al. "Score-based generative modeling through stochastic
- differential equations." https://arxiv.org/abs/2011.13456
-
- [`~ConfigMixin`] takes care of storing all config attributes that are passed in the scheduler's `__init__`
- function, such as `num_train_timesteps`. They can be accessed via `scheduler.config.num_train_timesteps`.
- [`SchedulerMixin`] provides general loading and saving functionality via the [`SchedulerMixin.save_pretrained`] and
- [`~SchedulerMixin.from_pretrained`] functions.
-
- For more details on the parameters, see the original paper's Appendix E.: "Elucidating the Design Space of
- Diffusion-Based Generative Models." https://arxiv.org/abs/2206.00364. The grid search values used to find the
- optimal {s_noise, s_churn, s_min, s_max} for a specific model are described in Table 5 of the paper.
-
- Args:
- sigma_min (`float`): minimum noise magnitude
- sigma_max (`float`): maximum noise magnitude
- s_noise (`float`): the amount of additional noise to counteract loss of detail during sampling.
- A reasonable range is [1.000, 1.011].
- s_churn (`float`): the parameter controlling the overall amount of stochasticity.
- A reasonable range is [0, 100].
- s_min (`float`): the start value of the sigma range where we add noise (enable stochasticity).
- A reasonable range is [0, 10].
- s_max (`float`): the end value of the sigma range where we add noise.
- A reasonable range is [0.2, 80].
-
- """
-
- order = 2
-
- @register_to_config
- def __init__(
- self,
- sigma_min: float = 0.02,
- sigma_max: float = 100,
- s_noise: float = 1.007,
- s_churn: float = 80,
- s_min: float = 0.05,
- s_max: float = 50,
- ):
- # standard deviation of the initial noise distribution
- self.init_noise_sigma = sigma_max
-
- # setable values
- self.num_inference_steps: int = None
- self.timesteps: np.IntTensor = None
- self.schedule: torch.FloatTensor = None # sigma(t_i)
-
- def scale_model_input(self, sample: torch.FloatTensor, timestep: Optional[int] = None) -> torch.FloatTensor:
- """
- Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
- current timestep.
-
- Args:
- sample (`torch.FloatTensor`): input sample
- timestep (`int`, optional): current timestep
-
- Returns:
- `torch.FloatTensor`: scaled input sample
- """
- return sample
-
- def set_timesteps(self, num_inference_steps: int, device: Union[str, torch.device] = None):
- """
- Sets the continuous timesteps used for the diffusion chain. Supporting function to be run before inference.
-
- Args:
- num_inference_steps (`int`):
- the number of diffusion steps used when generating samples with a pre-trained model.
-
- """
- self.num_inference_steps = num_inference_steps
- timesteps = np.arange(0, self.num_inference_steps)[::-1].copy()
- self.timesteps = torch.from_numpy(timesteps).to(device)
- schedule = [
- (
- self.config.sigma_max**2
- * (self.config.sigma_min**2 / self.config.sigma_max**2) ** (i / (num_inference_steps - 1))
- )
- for i in self.timesteps
- ]
- self.schedule = torch.tensor(schedule, dtype=torch.float32, device=device)
-
- def add_noise_to_input(
- self, sample: torch.FloatTensor, sigma: float, generator: Optional[torch.Generator] = None
- ) -> Tuple[torch.FloatTensor, float]:
- """
- Explicit Langevin-like "churn" step of adding noise to the sample according to a factor gamma_i ≥ 0 to reach a
- higher noise level sigma_hat = sigma_i + gamma_i*sigma_i.
-
- TODO Args:
- """
- if self.config.s_min <= sigma <= self.config.s_max:
- gamma = min(self.config.s_churn / self.num_inference_steps, 2**0.5 - 1)
- else:
- gamma = 0
-
- # sample eps ~ N(0, S_noise^2 * I)
- eps = self.config.s_noise * randn_tensor(sample.shape, generator=generator).to(sample.device)
- sigma_hat = sigma + gamma * sigma
- sample_hat = sample + ((sigma_hat**2 - sigma**2) ** 0.5 * eps)
-
- return sample_hat, sigma_hat
-
- def step(
- self,
- model_output: torch.FloatTensor,
- sigma_hat: float,
- sigma_prev: float,
- sample_hat: torch.FloatTensor,
- return_dict: bool = True,
- ) -> Union[KarrasVeOutput, Tuple]:
- """
- Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
- process from the learned model outputs (most often the predicted noise).
-
- Args:
- model_output (`torch.FloatTensor`): direct output from learned diffusion model.
- sigma_hat (`float`): TODO
- sigma_prev (`float`): TODO
- sample_hat (`torch.FloatTensor`): TODO
- return_dict (`bool`): option for returning tuple rather than KarrasVeOutput class
-
- KarrasVeOutput: updated sample in the diffusion chain and derivative (TODO double check).
- Returns:
- [`~schedulers.scheduling_karras_ve.KarrasVeOutput`] or `tuple`:
- [`~schedulers.scheduling_karras_ve.KarrasVeOutput`] if `return_dict` is True, otherwise a `tuple`. When
- returning a tuple, the first element is the sample tensor.
-
- """
-
- pred_original_sample = sample_hat + sigma_hat * model_output
- derivative = (sample_hat - pred_original_sample) / sigma_hat
- sample_prev = sample_hat + (sigma_prev - sigma_hat) * derivative
-
- if not return_dict:
- return (sample_prev, derivative)
-
- return KarrasVeOutput(
- prev_sample=sample_prev, derivative=derivative, pred_original_sample=pred_original_sample
- )
-
- def step_correct(
- self,
- model_output: torch.FloatTensor,
- sigma_hat: float,
- sigma_prev: float,
- sample_hat: torch.FloatTensor,
- sample_prev: torch.FloatTensor,
- derivative: torch.FloatTensor,
- return_dict: bool = True,
- ) -> Union[KarrasVeOutput, Tuple]:
- """
- Correct the predicted sample based on the output model_output of the network. TODO complete description
-
- Args:
- model_output (`torch.FloatTensor`): direct output from learned diffusion model.
- sigma_hat (`float`): TODO
- sigma_prev (`float`): TODO
- sample_hat (`torch.FloatTensor`): TODO
- sample_prev (`torch.FloatTensor`): TODO
- derivative (`torch.FloatTensor`): TODO
- return_dict (`bool`): option for returning tuple rather than KarrasVeOutput class
-
- Returns:
- prev_sample (TODO): updated sample in the diffusion chain. derivative (TODO): TODO
-
- """
- pred_original_sample = sample_prev + sigma_prev * model_output
- derivative_corr = (sample_prev - pred_original_sample) / sigma_prev
- sample_prev = sample_hat + (sigma_prev - sigma_hat) * (0.5 * derivative + 0.5 * derivative_corr)
-
- if not return_dict:
- return (sample_prev, derivative)
-
- return KarrasVeOutput(
- prev_sample=sample_prev, derivative=derivative, pred_original_sample=pred_original_sample
- )
-
- def add_noise(self, original_samples, noise, timesteps):
- raise NotImplementedError()
diff --git a/spaces/devthedeveloper/Bark-with-Voice-Cloning/util/settings.py b/spaces/devthedeveloper/Bark-with-Voice-Cloning/util/settings.py
deleted file mode 100644
index 2ab66b0c7605d2b877defdd8592097a8a4c6f21a..0000000000000000000000000000000000000000
--- a/spaces/devthedeveloper/Bark-with-Voice-Cloning/util/settings.py
+++ /dev/null
@@ -1,41 +0,0 @@
-import yaml
-
-class Settings:
- def __init__(self, config_file):
- self.config_file = config_file
- self.load()
-
- def load(self):
- try:
- with open(self.config_file, 'r') as f:
- data = yaml.load(f, Loader=yaml.FullLoader)
- self.selected_theme = data.get('selected_theme', "gstaff/xkcd")
- self.server_name = data.get('server_name', "")
- self.server_port = data.get('server_port', 0)
- self.server_share = data.get('server_share', False)
- self.input_text_desired_length = data.get('input_text_desired_length', 110)
- self.input_text_max_length = data.get('input_text_max_length', 170)
- self.silence_sentence = data.get('silence_between_sentences', 250)
- self.silence_speakers = data.get('silence_between_speakers', 500)
- self.output_folder_path = data.get('output_folder_path', 'outputs')
-
- except:
- self.selected_theme = "gstaff/xkcd"
-
- def save(self):
- data = {
- 'selected_theme': self.selected_theme,
- 'server_name': self.server_name,
- 'server_port': self.server_port,
- 'server_share': self.server_share,
- 'input_text_desired_length' : self.input_text_desired_length,
- 'input_text_max_length' : self.input_text_max_length,
- 'silence_between_sentences': self.silence_sentence,
- 'silence_between_speakers': self.silence_speakers,
- 'output_folder_path': self.output_folder_path
- }
- with open(self.config_file, 'w') as f:
- yaml.dump(data, f)
-
-
-
diff --git a/spaces/diacanFperku/AutoGPT/DataPC DX11 AC3 Homestead.forge.md b/spaces/diacanFperku/AutoGPT/DataPC DX11 AC3 Homestead.forge.md
deleted file mode 100644
index 20e804e167c132b89f20d7846f0ccc5d9230a7d2..0000000000000000000000000000000000000000
--- a/spaces/diacanFperku/AutoGPT/DataPC DX11 AC3 Homestead.forge.md
+++ /dev/null
@@ -1,14 +0,0 @@
-DataPC DX11 AC3 Homestead.forge
Download ✒ https://gohhs.com/2uFSYs
-
-luat si eu azi assasins creed III si cand se instaleaza imi da urmatorile erori:1)crc roor datapc dx11 ac3 boston.forge 2)crc eroor datapc . dx11 ac3 boston.
-3) crc instaleaza imi da urmatorile erori: boston.
-4) crc instaleaza imi da ur mnitorul ani eror: boston.
-5) crc instaleaza imi da urmatorile erori: boston.
-6) crc instaleaza imi da urmatorile erori: boston.
-7) crc instaleaza imi da urmatorile erori: boston.
-8) crc instaleaza imi da urmatorile erori: boston.
-9) crc instaleaza imi da urmatorile erori: boston.
-10) crc instaleaza imi da urmatorile 8a78ff9644
-
-
-
diff --git a/spaces/diacanFperku/AutoGPT/Korg Pa Manager V3 With Crack REPACK.md b/spaces/diacanFperku/AutoGPT/Korg Pa Manager V3 With Crack REPACK.md
deleted file mode 100644
index e4954727ce59cee2381f9051748313b2f47c6b6e..0000000000000000000000000000000000000000
--- a/spaces/diacanFperku/AutoGPT/Korg Pa Manager V3 With Crack REPACK.md
+++ /dev/null
@@ -1,6 +0,0 @@
-Korg pa manager v3 With Crack
DOWNLOAD >>> https://gohhs.com/2uFTrf
-
-7 Jan 2022 - KORG PA Manager Crack is a good and user friendly software. This professional software helps you to process many music files. You can use this software for professional or amateur use. It has many features such as file management, synthesizer management, MIDI management, MIDI settings management and more. The program has a multilingual interface that is very easy to use. You can also use it as a music editor or music player. This software is for you to enjoy music easily. 8a78ff9644
-
-
-
diff --git a/spaces/diagaiwei/ir_chinese_medqa/README.md b/spaces/diagaiwei/ir_chinese_medqa/README.md
deleted file mode 100644
index 2de3798f5a72ca09f270879db39709b07dbd6565..0000000000000000000000000000000000000000
--- a/spaces/diagaiwei/ir_chinese_medqa/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Ir Chinese Medqa
-emoji: 📉
-colorFrom: yellow
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.5
-app_file: app.py
-pinned: false
-license: openrail
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/diego2554/RemBG_super/rembg/session_cloth.py b/spaces/diego2554/RemBG_super/rembg/session_cloth.py
deleted file mode 100644
index 11bcef74378be4d64058772c29ac45240f60a85b..0000000000000000000000000000000000000000
--- a/spaces/diego2554/RemBG_super/rembg/session_cloth.py
+++ /dev/null
@@ -1,88 +0,0 @@
-from typing import List
-
-import numpy as np
-from PIL import Image
-from PIL.Image import Image as PILImage
-from scipy.special import log_softmax
-
-from .session_base import BaseSession
-
-pallete1 = [
- 0,
- 0,
- 0,
- 255,
- 255,
- 255,
- 0,
- 0,
- 0,
- 0,
- 0,
- 0,
-]
-
-pallete2 = [
- 0,
- 0,
- 0,
- 0,
- 0,
- 0,
- 255,
- 255,
- 255,
- 0,
- 0,
- 0,
-]
-
-pallete3 = [
- 0,
- 0,
- 0,
- 0,
- 0,
- 0,
- 0,
- 0,
- 0,
- 255,
- 255,
- 255,
-]
-
-
-class ClothSession(BaseSession):
- def predict(self, img: PILImage) -> List[PILImage]:
- ort_outs = self.inner_session.run(
- None, self.normalize(img, (0.5, 0.5, 0.5), (0.5, 0.5, 0.5), (768, 768))
- )
-
- pred = ort_outs
- pred = log_softmax(pred[0], 1)
- pred = np.argmax(pred, axis=1, keepdims=True)
- pred = np.squeeze(pred, 0)
- pred = np.squeeze(pred, 0)
-
- mask = Image.fromarray(pred.astype("uint8"), mode="L")
- mask = mask.resize(img.size, Image.LANCZOS)
-
- masks = []
-
- mask1 = mask.copy()
- mask1.putpalette(pallete1)
- mask1 = mask1.convert("RGB").convert("L")
- masks.append(mask1)
-
- mask2 = mask.copy()
- mask2.putpalette(pallete2)
- mask2 = mask2.convert("RGB").convert("L")
- masks.append(mask2)
-
- mask3 = mask.copy()
- mask3.putpalette(pallete3)
- mask3 = mask3.convert("RGB").convert("L")
- masks.append(mask3)
-
- return masks
diff --git a/spaces/digitalxingtong/Bufeiyan-a-Bert-VITS2/monotonic_align/setup.py b/spaces/digitalxingtong/Bufeiyan-a-Bert-VITS2/monotonic_align/setup.py
deleted file mode 100644
index 30c224807a70faa9df9c9eb75f8e80c8c867b16b..0000000000000000000000000000000000000000
--- a/spaces/digitalxingtong/Bufeiyan-a-Bert-VITS2/monotonic_align/setup.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from distutils.core import setup
-from Cython.Build import cythonize
-import numpy
-
-setup(
- name = 'monotonic_align',
- ext_modules = cythonize("core.pyx"),
- include_dirs=[numpy.get_include()]
-)
diff --git a/spaces/digitalxingtong/Miiu-Bert-Vits2/transcribe_genshin.py b/spaces/digitalxingtong/Miiu-Bert-Vits2/transcribe_genshin.py
deleted file mode 100644
index acc98814af6189d129ab85946525bec55419a33f..0000000000000000000000000000000000000000
--- a/spaces/digitalxingtong/Miiu-Bert-Vits2/transcribe_genshin.py
+++ /dev/null
@@ -1,78 +0,0 @@
-# coding=gbk
-import os
-import argparse
-import librosa
-import numpy as np
-from multiprocessing import Pool, cpu_count
-
-import soundfile
-from scipy.io import wavfile
-from tqdm import tqdm
-
-global speaker_annos
-speaker_annos = []
-
-def process(item):
- spkdir, wav_name, args = item
- speaker = spkdir.replace("\\", "/").split("/")[-1]
- wav_path = os.path.join(args.in_dir, speaker, wav_name)
- if os.path.exists(wav_path) and '.wav' in wav_path:
- os.makedirs(os.path.join(args.out_dir, speaker), exist_ok=True)
- wav, sr = librosa.load(wav_path, sr=args.sr)
- soundfile.write(
- os.path.join(args.out_dir, speaker, wav_name),
- wav,
- sr
- )
-
-def process_text(item):
- spkdir, wav_name, args = item
- speaker = spkdir.replace("\\", "/").split("/")[-1]
- wav_path = os.path.join(args.in_dir, speaker, wav_name)
- global speaker_annos
- tr_name = wav_name.replace('.wav', '')
- with open(args.out_dir+'/'+speaker+'/'+tr_name+'.lab', "r", encoding="utf-8") as file:
- text = file.read()
- text = text.replace("{NICKNAME}",'')
- text = text.replace("{M#}{F#}",'')
- text = text.replace("{M#}{F#}",'')
- substring = "{M#}{F#}"
- if substring in text:
- if tr_name.endswith("a"):
- text = text.replace("{M#}{F#}",'')
- if tr_name.endswith("b"):
- text = text.replace("{M#}{F#}",'')
- text = text.replace("#",'')
- text = "ZH|" + text + "\n" #
- speaker_annos.append(args.out_dir+'/'+speaker+'/'+wav_name+ "|" + speaker + "|" + text)
-
-
-
-if __name__ == "__main__":
- parent_dir = "./genshin_dataset/"
- speaker_names = list(os.walk(parent_dir))[0][1]
- parser = argparse.ArgumentParser()
- parser.add_argument("--sr", type=int, default=44100, help="sampling rate")
- parser.add_argument("--in_dir", type=str, default="./genshin_dataset", help="path to source dir")
- parser.add_argument("--out_dir", type=str, default="./genshin_dataset", help="path to target dir")
- args = parser.parse_args()
- # processs = 8
- processs = cpu_count()-2 if cpu_count() >4 else 1
- pool = Pool(processes=processs)
-
- for speaker in os.listdir(args.in_dir):
- spk_dir = os.path.join(args.in_dir, speaker)
- if os.path.isdir(spk_dir):
- print(spk_dir)
- for _ in tqdm(pool.imap_unordered(process, [(spk_dir, i, args) for i in os.listdir(spk_dir) if i.endswith("wav")])):
- pass
- for i in os.listdir(spk_dir):
- if i.endswith("wav"):
- pro=(spk_dir, i, args)
- process_text(pro)
- if len(speaker_annos) == 0:
- print("transcribe error!!!")
- with open("./filelists/short_character_anno.list", 'w', encoding='utf-8') as f:
- for line in speaker_annos:
- f.write(line)
- print("transcript file finished.")
diff --git a/spaces/digitalxingtong/Xingtong-2dall-Bert-VITS2/text/english.py b/spaces/digitalxingtong/Xingtong-2dall-Bert-VITS2/text/english.py
deleted file mode 100644
index 781d0a56cef71f66fc67db51d76538be90d3ddd2..0000000000000000000000000000000000000000
--- a/spaces/digitalxingtong/Xingtong-2dall-Bert-VITS2/text/english.py
+++ /dev/null
@@ -1,138 +0,0 @@
-import pickle
-import os
-import re
-from g2p_en import G2p
-from string import punctuation
-
-from text import symbols
-
-current_file_path = os.path.dirname(__file__)
-CMU_DICT_PATH = os.path.join(current_file_path, 'cmudict.rep')
-CACHE_PATH = os.path.join(current_file_path, 'cmudict_cache.pickle')
-_g2p = G2p()
-
-arpa = {'AH0', 'S', 'AH1', 'EY2', 'AE2', 'EH0', 'OW2', 'UH0', 'NG', 'B', 'G', 'AY0', 'M', 'AA0', 'F', 'AO0', 'ER2', 'UH1', 'IY1', 'AH2', 'DH', 'IY0', 'EY1', 'IH0', 'K', 'N', 'W', 'IY2', 'T', 'AA1', 'ER1', 'EH2', 'OY0', 'UH2', 'UW1', 'Z', 'AW2', 'AW1', 'V', 'UW2', 'AA2', 'ER', 'AW0', 'UW0', 'R', 'OW1', 'EH1', 'ZH', 'AE0', 'IH2', 'IH', 'Y', 'JH', 'P', 'AY1', 'EY0', 'OY2', 'TH', 'HH', 'D', 'ER0', 'CH', 'AO1', 'AE1', 'AO2', 'OY1', 'AY2', 'IH1', 'OW0', 'L', 'SH'}
-
-
-def post_replace_ph(ph):
- rep_map = {
- '：': ',',
- '；': ',',
- '，': ',',
- '。': '.',
- '！': '!',
- '？': '?',
- '\n': '.',
- "·": ",",
- '、': ",",
- '...': '…',
- 'v': "V"
- }
- if ph in rep_map.keys():
- ph = rep_map[ph]
- if ph in symbols:
- return ph
- if ph not in symbols:
- ph = 'UNK'
- return ph
-
-def read_dict():
- g2p_dict = {}
- start_line = 49
- with open(CMU_DICT_PATH) as f:
- line = f.readline()
- line_index = 1
- while line:
- if line_index >= start_line:
- line = line.strip()
- word_split = line.split(' ')
- word = word_split[0]
-
- syllable_split = word_split[1].split(' - ')
- g2p_dict[word] = []
- for syllable in syllable_split:
- phone_split = syllable.split(' ')
- g2p_dict[word].append(phone_split)
-
- line_index = line_index + 1
- line = f.readline()
-
- return g2p_dict
-
-
-def cache_dict(g2p_dict, file_path):
- with open(file_path, 'wb') as pickle_file:
- pickle.dump(g2p_dict, pickle_file)
-
-
-def get_dict():
- if os.path.exists(CACHE_PATH):
- with open(CACHE_PATH, 'rb') as pickle_file:
- g2p_dict = pickle.load(pickle_file)
- else:
- g2p_dict = read_dict()
- cache_dict(g2p_dict, CACHE_PATH)
-
- return g2p_dict
-
-eng_dict = get_dict()
-
-def refine_ph(phn):
- tone = 0
- if re.search(r'\d$', phn):
- tone = int(phn[-1]) + 1
- phn = phn[:-1]
- return phn.lower(), tone
-
-def refine_syllables(syllables):
- tones = []
- phonemes = []
- for phn_list in syllables:
- for i in range(len(phn_list)):
- phn = phn_list[i]
- phn, tone = refine_ph(phn)
- phonemes.append(phn)
- tones.append(tone)
- return phonemes, tones
-
-
-def text_normalize(text):
- # todo: eng text normalize
- return text
-
-def g2p(text):
-
- phones = []
- tones = []
- words = re.split(r"([,;.\-\?\!\s+])", text)
- for w in words:
- if w.upper() in eng_dict:
- phns, tns = refine_syllables(eng_dict[w.upper()])
- phones += phns
- tones += tns
- else:
- phone_list = list(filter(lambda p: p != " ", _g2p(w)))
- for ph in phone_list:
- if ph in arpa:
- ph, tn = refine_ph(ph)
- phones.append(ph)
- tones.append(tn)
- else:
- phones.append(ph)
- tones.append(0)
- # todo: implement word2ph
- word2ph = [1 for i in phones]
-
- phones = [post_replace_ph(i) for i in phones]
- return phones, tones, word2ph
-
-if __name__ == "__main__":
- # print(get_dict())
- # print(eng_word_to_phoneme("hello"))
- print(g2p("In this paper, we propose 1 DSPGAN, a GAN-based universal vocoder."))
- # all_phones = set()
- # for k, syllables in eng_dict.items():
- # for group in syllables:
- # for ph in group:
- # all_phones.add(ph)
- # print(all_phones)
\ No newline at end of file
diff --git a/spaces/dineshreddy/WALT/mmdet/core/bbox/samplers/instance_balanced_pos_sampler.py b/spaces/dineshreddy/WALT/mmdet/core/bbox/samplers/instance_balanced_pos_sampler.py
deleted file mode 100644
index c735298487e14e4a0ec42913f25673cccb98a8a0..0000000000000000000000000000000000000000
--- a/spaces/dineshreddy/WALT/mmdet/core/bbox/samplers/instance_balanced_pos_sampler.py
+++ /dev/null
@@ -1,55 +0,0 @@
-import numpy as np
-import torch
-
-from ..builder import BBOX_SAMPLERS
-from .random_sampler import RandomSampler
-
-
-@BBOX_SAMPLERS.register_module()
-class InstanceBalancedPosSampler(RandomSampler):
- """Instance balanced sampler that samples equal number of positive samples
- for each instance."""
-
- def _sample_pos(self, assign_result, num_expected, **kwargs):
- """Sample positive boxes.
-
- Args:
- assign_result (:obj:`AssignResult`): The assigned results of boxes.
- num_expected (int): The number of expected positive samples
-
- Returns:
- Tensor or ndarray: sampled indices.
- """
- pos_inds = torch.nonzero(assign_result.gt_inds > 0, as_tuple=False)
- if pos_inds.numel() != 0:
- pos_inds = pos_inds.squeeze(1)
- if pos_inds.numel() <= num_expected:
- return pos_inds
- else:
- unique_gt_inds = assign_result.gt_inds[pos_inds].unique()
- num_gts = len(unique_gt_inds)
- num_per_gt = int(round(num_expected / float(num_gts)) + 1)
- sampled_inds = []
- for i in unique_gt_inds:
- inds = torch.nonzero(
- assign_result.gt_inds == i.item(), as_tuple=False)
- if inds.numel() != 0:
- inds = inds.squeeze(1)
- else:
- continue
- if len(inds) > num_per_gt:
- inds = self.random_choice(inds, num_per_gt)
- sampled_inds.append(inds)
- sampled_inds = torch.cat(sampled_inds)
- if len(sampled_inds) < num_expected:
- num_extra = num_expected - len(sampled_inds)
- extra_inds = np.array(
- list(set(pos_inds.cpu()) - set(sampled_inds.cpu())))
- if len(extra_inds) > num_extra:
- extra_inds = self.random_choice(extra_inds, num_extra)
- extra_inds = torch.from_numpy(extra_inds).to(
- assign_result.gt_inds.device).long()
- sampled_inds = torch.cat([sampled_inds, extra_inds])
- elif len(sampled_inds) > num_expected:
- sampled_inds = self.random_choice(sampled_inds, num_expected)
- return sampled_inds
diff --git a/spaces/dineshreddy/WALT/mmdet/models/losses/iou_loss.py b/spaces/dineshreddy/WALT/mmdet/models/losses/iou_loss.py
deleted file mode 100644
index eba6f18b80981ca891c1add37007e6bf478c651f..0000000000000000000000000000000000000000
--- a/spaces/dineshreddy/WALT/mmdet/models/losses/iou_loss.py
+++ /dev/null
@@ -1,436 +0,0 @@
-import math
-
-import mmcv
-import torch
-import torch.nn as nn
-
-from mmdet.core import bbox_overlaps
-from ..builder import LOSSES
-from .utils import weighted_loss
-
-
-@mmcv.jit(derivate=True, coderize=True)
-@weighted_loss
-def iou_loss(pred, target, linear=False, eps=1e-6):
- """IoU loss.
-
- Computing the IoU loss between a set of predicted bboxes and target bboxes.
- The loss is calculated as negative log of IoU.
-
- Args:
- pred (torch.Tensor): Predicted bboxes of format (x1, y1, x2, y2),
- shape (n, 4).
- target (torch.Tensor): Corresponding gt bboxes, shape (n, 4).
- linear (bool, optional): If True, use linear scale of loss instead of
- log scale. Default: False.
- eps (float): Eps to avoid log(0).
-
- Return:
- torch.Tensor: Loss tensor.
- """
- ious = bbox_overlaps(pred, target, is_aligned=True).clamp(min=eps)
- if linear:
- loss = 1 - ious
- else:
- loss = -ious.log()
- return loss
-
-
-@mmcv.jit(derivate=True, coderize=True)
-@weighted_loss
-def bounded_iou_loss(pred, target, beta=0.2, eps=1e-3):
- """BIoULoss.
-
- This is an implementation of paper
- `Improving Object Localization with Fitness NMS and Bounded IoU Loss.
- `_.
-
- Args:
- pred (torch.Tensor): Predicted bboxes.
- target (torch.Tensor): Target bboxes.
- beta (float): beta parameter in smoothl1.
- eps (float): eps to avoid NaN.
- """
- pred_ctrx = (pred[:, 0] + pred[:, 2]) * 0.5
- pred_ctry = (pred[:, 1] + pred[:, 3]) * 0.5
- pred_w = pred[:, 2] - pred[:, 0]
- pred_h = pred[:, 3] - pred[:, 1]
- with torch.no_grad():
- target_ctrx = (target[:, 0] + target[:, 2]) * 0.5
- target_ctry = (target[:, 1] + target[:, 3]) * 0.5
- target_w = target[:, 2] - target[:, 0]
- target_h = target[:, 3] - target[:, 1]
-
- dx = target_ctrx - pred_ctrx
- dy = target_ctry - pred_ctry
-
- loss_dx = 1 - torch.max(
- (target_w - 2 * dx.abs()) /
- (target_w + 2 * dx.abs() + eps), torch.zeros_like(dx))
- loss_dy = 1 - torch.max(
- (target_h - 2 * dy.abs()) /
- (target_h + 2 * dy.abs() + eps), torch.zeros_like(dy))
- loss_dw = 1 - torch.min(target_w / (pred_w + eps), pred_w /
- (target_w + eps))
- loss_dh = 1 - torch.min(target_h / (pred_h + eps), pred_h /
- (target_h + eps))
- loss_comb = torch.stack([loss_dx, loss_dy, loss_dw, loss_dh],
- dim=-1).view(loss_dx.size(0), -1)
-
- loss = torch.where(loss_comb < beta, 0.5 * loss_comb * loss_comb / beta,
- loss_comb - 0.5 * beta)
- return loss
-
-
-@mmcv.jit(derivate=True, coderize=True)
-@weighted_loss
-def giou_loss(pred, target, eps=1e-7):
- r"""`Generalized Intersection over Union: A Metric and A Loss for Bounding
- Box Regression `_.
-
- Args:
- pred (torch.Tensor): Predicted bboxes of format (x1, y1, x2, y2),
- shape (n, 4).
- target (torch.Tensor): Corresponding gt bboxes, shape (n, 4).
- eps (float): Eps to avoid log(0).
-
- Return:
- Tensor: Loss tensor.
- """
- gious = bbox_overlaps(pred, target, mode='giou', is_aligned=True, eps=eps)
- loss = 1 - gious
- return loss
-
-
-@mmcv.jit(derivate=True, coderize=True)
-@weighted_loss
-def diou_loss(pred, target, eps=1e-7):
- r"""`Implementation of Distance-IoU Loss: Faster and Better
- Learning for Bounding Box Regression, https://arxiv.org/abs/1911.08287`_.
-
- Code is modified from https://github.com/Zzh-tju/DIoU.
-
- Args:
- pred (Tensor): Predicted bboxes of format (x1, y1, x2, y2),
- shape (n, 4).
- target (Tensor): Corresponding gt bboxes, shape (n, 4).
- eps (float): Eps to avoid log(0).
- Return:
- Tensor: Loss tensor.
- """
- # overlap
- lt = torch.max(pred[:, :2], target[:, :2])
- rb = torch.min(pred[:, 2:], target[:, 2:])
- wh = (rb - lt).clamp(min=0)
- overlap = wh[:, 0] * wh[:, 1]
-
- # union
- ap = (pred[:, 2] - pred[:, 0]) * (pred[:, 3] - pred[:, 1])
- ag = (target[:, 2] - target[:, 0]) * (target[:, 3] - target[:, 1])
- union = ap + ag - overlap + eps
-
- # IoU
- ious = overlap / union
-
- # enclose area
- enclose_x1y1 = torch.min(pred[:, :2], target[:, :2])
- enclose_x2y2 = torch.max(pred[:, 2:], target[:, 2:])
- enclose_wh = (enclose_x2y2 - enclose_x1y1).clamp(min=0)
-
- cw = enclose_wh[:, 0]
- ch = enclose_wh[:, 1]
-
- c2 = cw**2 + ch**2 + eps
-
- b1_x1, b1_y1 = pred[:, 0], pred[:, 1]
- b1_x2, b1_y2 = pred[:, 2], pred[:, 3]
- b2_x1, b2_y1 = target[:, 0], target[:, 1]
- b2_x2, b2_y2 = target[:, 2], target[:, 3]
-
- left = ((b2_x1 + b2_x2) - (b1_x1 + b1_x2))**2 / 4
- right = ((b2_y1 + b2_y2) - (b1_y1 + b1_y2))**2 / 4
- rho2 = left + right
-
- # DIoU
- dious = ious - rho2 / c2
- loss = 1 - dious
- return loss
-
-
-@mmcv.jit(derivate=True, coderize=True)
-@weighted_loss
-def ciou_loss(pred, target, eps=1e-7):
- r"""`Implementation of paper `Enhancing Geometric Factors into
- Model Learning and Inference for Object Detection and Instance
- Segmentation `_.
-
- Code is modified from https://github.com/Zzh-tju/CIoU.
-
- Args:
- pred (Tensor): Predicted bboxes of format (x1, y1, x2, y2),
- shape (n, 4).
- target (Tensor): Corresponding gt bboxes, shape (n, 4).
- eps (float): Eps to avoid log(0).
- Return:
- Tensor: Loss tensor.
- """
- # overlap
- lt = torch.max(pred[:, :2], target[:, :2])
- rb = torch.min(pred[:, 2:], target[:, 2:])
- wh = (rb - lt).clamp(min=0)
- overlap = wh[:, 0] * wh[:, 1]
-
- # union
- ap = (pred[:, 2] - pred[:, 0]) * (pred[:, 3] - pred[:, 1])
- ag = (target[:, 2] - target[:, 0]) * (target[:, 3] - target[:, 1])
- union = ap + ag - overlap + eps
-
- # IoU
- ious = overlap / union
-
- # enclose area
- enclose_x1y1 = torch.min(pred[:, :2], target[:, :2])
- enclose_x2y2 = torch.max(pred[:, 2:], target[:, 2:])
- enclose_wh = (enclose_x2y2 - enclose_x1y1).clamp(min=0)
-
- cw = enclose_wh[:, 0]
- ch = enclose_wh[:, 1]
-
- c2 = cw**2 + ch**2 + eps
-
- b1_x1, b1_y1 = pred[:, 0], pred[:, 1]
- b1_x2, b1_y2 = pred[:, 2], pred[:, 3]
- b2_x1, b2_y1 = target[:, 0], target[:, 1]
- b2_x2, b2_y2 = target[:, 2], target[:, 3]
-
- w1, h1 = b1_x2 - b1_x1, b1_y2 - b1_y1 + eps
- w2, h2 = b2_x2 - b2_x1, b2_y2 - b2_y1 + eps
-
- left = ((b2_x1 + b2_x2) - (b1_x1 + b1_x2))**2 / 4
- right = ((b2_y1 + b2_y2) - (b1_y1 + b1_y2))**2 / 4
- rho2 = left + right
-
- factor = 4 / math.pi**2
- v = factor * torch.pow(torch.atan(w2 / h2) - torch.atan(w1 / h1), 2)
-
- # CIoU
- cious = ious - (rho2 / c2 + v**2 / (1 - ious + v))
- loss = 1 - cious
- return loss
-
-
-@LOSSES.register_module()
-class IoULoss(nn.Module):
- """IoULoss.
-
- Computing the IoU loss between a set of predicted bboxes and target bboxes.
-
- Args:
- linear (bool): If True, use linear scale of loss instead of log scale.
- Default: False.
- eps (float): Eps to avoid log(0).
- reduction (str): Options are "none", "mean" and "sum".
- loss_weight (float): Weight of loss.
- """
-
- def __init__(self,
- linear=False,
- eps=1e-6,
- reduction='mean',
- loss_weight=1.0):
- super(IoULoss, self).__init__()
- self.linear = linear
- self.eps = eps
- self.reduction = reduction
- self.loss_weight = loss_weight
-
- def forward(self,
- pred,
- target,
- weight=None,
- avg_factor=None,
- reduction_override=None,
- **kwargs):
- """Forward function.
-
- Args:
- pred (torch.Tensor): The prediction.
- target (torch.Tensor): The learning target of the prediction.
- weight (torch.Tensor, optional): The weight of loss for each
- prediction. Defaults to None.
- avg_factor (int, optional): Average factor that is used to average
- the loss. Defaults to None.
- reduction_override (str, optional): The reduction method used to
- override the original reduction method of the loss.
- Defaults to None. Options are "none", "mean" and "sum".
- """
- assert reduction_override in (None, 'none', 'mean', 'sum')
- reduction = (
- reduction_override if reduction_override else self.reduction)
- if (weight is not None) and (not torch.any(weight > 0)) and (
- reduction != 'none'):
- return (pred * weight).sum() # 0
- if weight is not None and weight.dim() > 1:
- # TODO: remove this in the future
- # reduce the weight of shape (n, 4) to (n,) to match the
- # iou_loss of shape (n,)
- assert weight.shape == pred.shape
- weight = weight.mean(-1)
- loss = self.loss_weight * iou_loss(
- pred,
- target,
- weight,
- linear=self.linear,
- eps=self.eps,
- reduction=reduction,
- avg_factor=avg_factor,
- **kwargs)
- return loss
-
-
-@LOSSES.register_module()
-class BoundedIoULoss(nn.Module):
-
- def __init__(self, beta=0.2, eps=1e-3, reduction='mean', loss_weight=1.0):
- super(BoundedIoULoss, self).__init__()
- self.beta = beta
- self.eps = eps
- self.reduction = reduction
- self.loss_weight = loss_weight
-
- def forward(self,
- pred,
- target,
- weight=None,
- avg_factor=None,
- reduction_override=None,
- **kwargs):
- if weight is not None and not torch.any(weight > 0):
- return (pred * weight).sum() # 0
- assert reduction_override in (None, 'none', 'mean', 'sum')
- reduction = (
- reduction_override if reduction_override else self.reduction)
- loss = self.loss_weight * bounded_iou_loss(
- pred,
- target,
- weight,
- beta=self.beta,
- eps=self.eps,
- reduction=reduction,
- avg_factor=avg_factor,
- **kwargs)
- return loss
-
-
-@LOSSES.register_module()
-class GIoULoss(nn.Module):
-
- def __init__(self, eps=1e-6, reduction='mean', loss_weight=1.0):
- super(GIoULoss, self).__init__()
- self.eps = eps
- self.reduction = reduction
- self.loss_weight = loss_weight
-
- def forward(self,
- pred,
- target,
- weight=None,
- avg_factor=None,
- reduction_override=None,
- **kwargs):
- if weight is not None and not torch.any(weight > 0):
- return (pred * weight).sum() # 0
- assert reduction_override in (None, 'none', 'mean', 'sum')
- reduction = (
- reduction_override if reduction_override else self.reduction)
- if weight is not None and weight.dim() > 1:
- # TODO: remove this in the future
- # reduce the weight of shape (n, 4) to (n,) to match the
- # giou_loss of shape (n,)
- assert weight.shape == pred.shape
- weight = weight.mean(-1)
- loss = self.loss_weight * giou_loss(
- pred,
- target,
- weight,
- eps=self.eps,
- reduction=reduction,
- avg_factor=avg_factor,
- **kwargs)
- return loss
-
-
-@LOSSES.register_module()
-class DIoULoss(nn.Module):
-
- def __init__(self, eps=1e-6, reduction='mean', loss_weight=1.0):
- super(DIoULoss, self).__init__()
- self.eps = eps
- self.reduction = reduction
- self.loss_weight = loss_weight
-
- def forward(self,
- pred,
- target,
- weight=None,
- avg_factor=None,
- reduction_override=None,
- **kwargs):
- if weight is not None and not torch.any(weight > 0):
- return (pred * weight).sum() # 0
- assert reduction_override in (None, 'none', 'mean', 'sum')
- reduction = (
- reduction_override if reduction_override else self.reduction)
- if weight is not None and weight.dim() > 1:
- # TODO: remove this in the future
- # reduce the weight of shape (n, 4) to (n,) to match the
- # giou_loss of shape (n,)
- assert weight.shape == pred.shape
- weight = weight.mean(-1)
- loss = self.loss_weight * diou_loss(
- pred,
- target,
- weight,
- eps=self.eps,
- reduction=reduction,
- avg_factor=avg_factor,
- **kwargs)
- return loss
-
-
-@LOSSES.register_module()
-class CIoULoss(nn.Module):
-
- def __init__(self, eps=1e-6, reduction='mean', loss_weight=1.0):
- super(CIoULoss, self).__init__()
- self.eps = eps
- self.reduction = reduction
- self.loss_weight = loss_weight
-
- def forward(self,
- pred,
- target,
- weight=None,
- avg_factor=None,
- reduction_override=None,
- **kwargs):
- if weight is not None and not torch.any(weight > 0):
- return (pred * weight).sum() # 0
- assert reduction_override in (None, 'none', 'mean', 'sum')
- reduction = (
- reduction_override if reduction_override else self.reduction)
- if weight is not None and weight.dim() > 1:
- # TODO: remove this in the future
- # reduce the weight of shape (n, 4) to (n,) to match the
- # giou_loss of shape (n,)
- assert weight.shape == pred.shape
- weight = weight.mean(-1)
- loss = self.loss_weight * ciou_loss(
- pred,
- target,
- weight,
- eps=self.eps,
- reduction=reduction,
- avg_factor=avg_factor,
- **kwargs)
- return loss
diff --git a/spaces/djillegal/illegal_stable_img2img/README.md b/spaces/djillegal/illegal_stable_img2img/README.md
deleted file mode 100644
index 51e466958b0bbc4b161b069b694f46c6e150ea12..0000000000000000000000000000000000000000
--- a/spaces/djillegal/illegal_stable_img2img/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Illegal Stable Img2img
-emoji: 🐨
-colorFrom: indigo
-colorTo: green
-sdk: gradio
-sdk_version: 3.15.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/doevent/3D_Photo_Inpainting/MiDaS/MiDaS_utils.py b/spaces/doevent/3D_Photo_Inpainting/MiDaS/MiDaS_utils.py
deleted file mode 100644
index f961acdd797624ee802fdddc3d69344094009887..0000000000000000000000000000000000000000
--- a/spaces/doevent/3D_Photo_Inpainting/MiDaS/MiDaS_utils.py
+++ /dev/null
@@ -1,192 +0,0 @@
-"""Utils for monoDepth.
-"""
-import sys
-import re
-import numpy as np
-import cv2
-import torch
-import imageio
-
-
-def read_pfm(path):
- """Read pfm file.
-
- Args:
- path (str): path to file
-
- Returns:
- tuple: (data, scale)
- """
- with open(path, "rb") as file:
-
- color = None
- width = None
- height = None
- scale = None
- endian = None
-
- header = file.readline().rstrip()
- if header.decode("ascii") == "PF":
- color = True
- elif header.decode("ascii") == "Pf":
- color = False
- else:
- raise Exception("Not a PFM file: " + path)
-
- dim_match = re.match(r"^(\d+)\s(\d+)\s$", file.readline().decode("ascii"))
- if dim_match:
- width, height = list(map(int, dim_match.groups()))
- else:
- raise Exception("Malformed PFM header.")
-
- scale = float(file.readline().decode("ascii").rstrip())
- if scale < 0:
- # little-endian
- endian = "<"
- scale = -scale
- else:
- # big-endian
- endian = ">"
-
- data = np.fromfile(file, endian + "f")
- shape = (height, width, 3) if color else (height, width)
-
- data = np.reshape(data, shape)
- data = np.flipud(data)
-
- return data, scale
-
-
-def write_pfm(path, image, scale=1):
- """Write pfm file.
-
- Args:
- path (str): pathto file
- image (array): data
- scale (int, optional): Scale. Defaults to 1.
- """
-
- with open(path, "wb") as file:
- color = None
-
- if image.dtype.name != "float32":
- raise Exception("Image dtype must be float32.")
-
- image = np.flipud(image)
-
- if len(image.shape) == 3 and image.shape[2] == 3: # color image
- color = True
- elif (
- len(image.shape) == 2 or len(image.shape) == 3 and image.shape[2] == 1
- ): # greyscale
- color = False
- else:
- raise Exception("Image must have H x W x 3, H x W x 1 or H x W dimensions.")
-
- file.write("PF\n" if color else "Pf\n".encode())
- file.write("%d %d\n".encode() % (image.shape[1], image.shape[0]))
-
- endian = image.dtype.byteorder
-
- if endian == "<" or endian == "=" and sys.byteorder == "little":
- scale = -scale
-
- file.write("%f\n".encode() % scale)
-
- image.tofile(file)
-
-
-def read_image(path):
- """Read image and output RGB image (0-1).
-
- Args:
- path (str): path to file
-
- Returns:
- array: RGB image (0-1)
- """
- img = cv2.imread(path)
-
- if img.ndim == 2:
- img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
-
- img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) / 255.0
-
- return img
-
-
-def resize_image(img):
- """Resize image and make it fit for network.
-
- Args:
- img (array): image
-
- Returns:
- tensor: data ready for network
- """
- height_orig = img.shape[0]
- width_orig = img.shape[1]
- unit_scale = 384.
-
- if width_orig > height_orig:
- scale = width_orig / unit_scale
- else:
- scale = height_orig / unit_scale
-
- height = (np.ceil(height_orig / scale / 32) * 32).astype(int)
- width = (np.ceil(width_orig / scale / 32) * 32).astype(int)
-
- img_resized = cv2.resize(img, (width, height), interpolation=cv2.INTER_AREA)
-
- img_resized = (
- torch.from_numpy(np.transpose(img_resized, (2, 0, 1))).contiguous().float()
- )
- img_resized = img_resized.unsqueeze(0)
-
- return img_resized
-
-
-def resize_depth(depth, width, height):
- """Resize depth map and bring to CPU (numpy).
-
- Args:
- depth (tensor): depth
- width (int): image width
- height (int): image height
-
- Returns:
- array: processed depth
- """
- depth = torch.squeeze(depth[0, :, :, :]).to("cpu")
- depth = cv2.blur(depth.numpy(), (3, 3))
- depth_resized = cv2.resize(
- depth, (width, height), interpolation=cv2.INTER_AREA
- )
-
- return depth_resized
-
-def write_depth(path, depth, bits=1):
- """Write depth map to pfm and png file.
-
- Args:
- path (str): filepath without extension
- depth (array): depth
- """
- # write_pfm(path + ".pfm", depth.astype(np.float32))
-
- depth_min = depth.min()
- depth_max = depth.max()
-
- max_val = (2**(8*bits))-1
-
- if depth_max - depth_min > np.finfo("float").eps:
- out = max_val * (depth - depth_min) / (depth_max - depth_min)
- else:
- out = 0
-
- if bits == 1:
- cv2.imwrite(path + ".png", out.astype("uint8"))
- elif bits == 2:
- cv2.imwrite(path + ".png", out.astype("uint16"))
-
- return
\ No newline at end of file
diff --git a/spaces/duycse1603/math2tex/HybridViT/module/component/prediction_head/seq2seq.py b/spaces/duycse1603/math2tex/HybridViT/module/component/prediction_head/seq2seq.py
deleted file mode 100644
index 0920f5035bc50914b3414a6c78302be2b83fb1cd..0000000000000000000000000000000000000000
--- a/spaces/duycse1603/math2tex/HybridViT/module/component/prediction_head/seq2seq.py
+++ /dev/null
@@ -1,268 +0,0 @@
-import random
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from einops import repeat
-from ...converter import AttnLabelConverter as ATTN
-from .addon_module import *
-
-class Attention(nn.Module):
- def __init__(self,
- kernel_size,
- kernel_dim,
- input_size,
- hidden_size,
- num_classes,
- embed_dim=None,
- attn_type='coverage',
- embed_target=False,
- enc_init=False, #init hidden state of decoder with enc output
- teacher_forcing=1.0,
- droprate=0.1,
- method='concat',
- seqmodel='ViT',
- viz_attn: bool = False,
- device='cuda'
- ):
- super(Attention, self).__init__()
- if embed_dim is None: embed_dim = input_size
- if embed_target:
- self.embedding = nn.Embedding(num_classes, embed_dim, padding_idx=ATTN.START())
-
- common = {
- 'input_size': input_size,
- 'hidden_size': hidden_size,
- 'num_embeddings': embed_dim if embed_target else num_classes,
- 'num_classes': num_classes
- }
-
- if attn_type == 'luong':
- common['method'] = method
- self.attention_cell = LuongAttention(**common)
- elif attn_type == 'loc_aware':
- self.attention_cell = LocationAwareAttention(kernel_size=kernel_size, kernel_dim=kernel_dim, **common)
- elif attn_type == 'coverage':
- self.attention_cell = LocationAwareAttention(kernel_size=kernel_size, kernel_dim=kernel_dim, **common)
- else:
- self.attention_cell = BahdanauAttention(**common)
-
- self.dropout = nn.Dropout(droprate)
- self.embed_target = embed_target
- self.hidden_size = hidden_size
- self.input_size = input_size
- self.num_classes = num_classes
- self.teacher_forcing = teacher_forcing
- self.device = device
- self.attn_type = attn_type
- self.enc_init = enc_init
- self.viz_attn = viz_attn
- self.seqmodel = seqmodel
-
- if enc_init: self.init_hidden()
-
- def _embed_text(self, input_char):
- return self.embedding(input_char)
-
- def _char_to_onehot(self, input_char, onehot_dim=38):
- input_char = input_char.unsqueeze(1)
- batch_size = input_char.size(0)
- one_hot = torch.FloatTensor(batch_size, onehot_dim).zero_().to(self.device)
- one_hot = one_hot.scatter_(1, input_char, 1)
- return one_hot
-
- def init_hidden(self):
- self.proj_init_h = nn.Linear(self.input_size, self.hidden_size, bias=True)
- self.proj_init_c = nn.Linear(self.input_size, self.hidden_size, bias=True)
-
- def forward_beam(
- self,
- batch_H: torch.Tensor,
- batch_max_length=25,
- beam_size=4,
- ):
- batch_size = batch_H.size(0)
- assert batch_size == 1
- num_steps = batch_max_length + 1
- batch_H = batch_H.squeeze(dim=0)
- batch_H = repeat(batch_H, "s e -> b s e", b = beam_size)
-
- if self.enc_init:
- if self.seqmodel == 'BiLSTM':
- init_embedding = batch_H.mean(dim=1)
- else:
- init_embedding = batch_H[:, 0, :]
- h_0 = self.proj_init_h(init_embedding)
- c_0 = self.proj_init_c(init_embedding)
- hidden = (h_0, c_0)
- else:
- hidden = (torch.zeros(beam_size, self.hidden_size, dtype=torch.float32, device=self.device),
- torch.zeros(beam_size, self.hidden_size, dtype=torch.float32, device=self.device))
-
- if self.attn_type == 'coverage':
- alpha_cum = torch.zeros(beam_size, batch_H.shape[1], 1, dtype=torch.float32, device=self.device)
- self.attention_cell.reset_mem()
-
- k_prev_words = torch.LongTensor([[ATTN.START()]] * beam_size).to(self.device)
- seqs = k_prev_words
- targets = k_prev_words.squeeze(dim=-1)
- top_k_scores = torch.zeros(beam_size, 1).to(self.device)
-
- if self.viz_attn:
- seqs_alpha = torch.ones(beam_size, 1, batch_H.shape[1]).to(self.device)
-
- complete_seqs = list()
- if self.viz_attn:
- complete_seqs_alpha = list()
- complete_seqs_scores = list()
-
- for step in range(num_steps):
- embed_text = self._char_to_onehot(targets, onehot_dim=self.num_classes) if not self.embed_target else self._embed_text(targets)
- output, hidden, alpha = self.attention_cell(hidden, batch_H, embed_text)
- output = self.dropout(output)
- vocab_size = output.shape[1]
-
- scores = F.log_softmax(output, dim=-1)
- scores = top_k_scores.expand_as(scores) + scores
- if step == 0:
- top_k_scores, top_k_words = scores[0].topk(beam_size, 0, True, True)
- else:
- top_k_scores, top_k_words = scores.view(-1).topk(beam_size, 0, True, True)
-
- prev_word_inds = top_k_words // vocab_size
- next_word_inds = top_k_words % vocab_size
-
- seqs = torch.cat([seqs[prev_word_inds], next_word_inds.unsqueeze(1)], dim=1)
- if self.viz_attn:
- seqs_alpha = torch.cat([seqs_alpha[prev_word_inds], alpha[prev_word_inds].permute(0, 2, 1)],
- dim=1)
-
- incomplete_inds = [ind for ind, next_word in enumerate(next_word_inds) if
- next_word != ATTN.END()]
-
- complete_inds = list(set(range(len(next_word_inds))) - set(incomplete_inds))
-
- if len(complete_inds) > 0:
- complete_seqs.extend(seqs[complete_inds].tolist())
- if self.viz_attn:
- complete_seqs_alpha.extend(seqs_alpha[complete_inds])
- complete_seqs_scores.extend(top_k_scores[complete_inds])
-
- beam_size = beam_size - len(complete_inds)
- if beam_size == 0:
- break
-
- seqs = seqs[incomplete_inds]
- if self.viz_attn:
- seqs_alpha = seqs_alpha[incomplete_inds]
- hidden = hidden[0][prev_word_inds[incomplete_inds]], \
- hidden[1][prev_word_inds[incomplete_inds]]
- batch_H = batch_H[prev_word_inds[incomplete_inds]]
- top_k_scores = top_k_scores[incomplete_inds].unsqueeze(1)
- targets = next_word_inds[incomplete_inds]
-
- if self.attn_type == 'coverage':
- alpha_cum = alpha_cum + alpha
- alpha_cum = alpha_cum[incomplete_inds]
- self.attention_cell.set_mem(alpha_cum)
- elif self.attn_type == 'loc_aware':
- self.attention_cell.set_mem(alpha)
-
- if len(complete_inds) == 0:
- seq = seqs[0][1:].tolist()
- seq = torch.LongTensor(seq).unsqueeze(0)
- score = top_k_scores[0]
- if self.viz_attn:
- alphas = seqs_alpha[0][1:, ...]
- return seq, score, alphas
- else:
- return seq, score, None
- else:
- combine_lst = tuple(zip(complete_seqs, complete_seqs_scores))
- best_ind = combine_lst.index(max(combine_lst, key=lambda x: x[1] / len(x[0]))) #https://youtu.be/XXtpJxZBa2c?t=2407
- seq = complete_seqs[best_ind][1:] #not include [GO] token
- seq = torch.LongTensor(seq).unsqueeze(0)
- score = max(complete_seqs_scores)
-
- if self.viz_attn:
- alphas = complete_seqs_alpha[best_ind][1:, ...]
- return seq, score, alphas
- else:
- return seq, score, None
-
- def forward_greedy(self, batch_H, text, is_train=True, is_test=False, batch_max_length=25):
- batch_size = batch_H.size(0)
- num_steps = batch_max_length + 1
- if self.enc_init:
- if self.seqmodel == 'BiLSTM':
- init_embedding = batch_H.mean(dim=1)
- encoder_hidden = batch_H
- else:
- encoder_hidden = batch_H
- init_embedding = batch_H[:, 0, :]
- h_0 = self.proj_init_h(init_embedding)
- c_0 = self.proj_init_c(init_embedding)
- hidden = (h_0, c_0)
- else:
- encoder_hidden = batch_H
- hidden = (torch.zeros(batch_size, self.hidden_size, dtype=torch.float32, device=self.device),
- torch.zeros(batch_size, self.hidden_size, dtype=torch.float32, device=self.device))
-
- targets = torch.zeros(batch_size, dtype=torch.long, device=self.device) # [GO] token
- probs = torch.zeros(batch_size, num_steps, self.num_classes, dtype=torch.float32, device=self.device)
-
- if self.viz_attn:
- self.alpha_stores = torch.zeros(batch_size, num_steps, encoder_hidden.shape[1], 1, dtype=torch.float32, device=self.device)
- if self.attn_type == 'coverage':
- alpha_cum = torch.zeros(batch_size, encoder_hidden.shape[1], 1, dtype=torch.float32, device=self.device)
-
- self.attention_cell.reset_mem()
-
- if is_test:
- end_flag = torch.zeros(batch_size, dtype=torch.bool, device=self.device)
-
- for i in range(num_steps):
- embed_text = self._char_to_onehot(targets, onehot_dim=self.num_classes) if not self.embed_target else self._embed_text(targets)
- output, hidden, alpha = self.attention_cell(hidden, encoder_hidden, embed_text)
- output = self.dropout(output)
- if self.viz_attn:
- self.alpha_stores[:, i] = alpha
- if self.attn_type == 'coverage':
- alpha_cum = alpha_cum + alpha
- self.attention_cell.set_mem(alpha_cum)
- elif self.attn_type == 'loc_aware':
- self.attention_cell.set_mem(alpha)
-
- probs_step = output
- probs[:, i, :] = probs_step
-
- if i == num_steps - 1:
- break
-
- if is_train:
- if self.teacher_forcing < random.random():
- _, next_input = probs_step.max(1)
- targets = next_input
- else:
- targets = text[:, i+1]
- else:
- _, next_input = probs_step.max(1)
- targets = next_input
-
- if is_test:
- end_flag = end_flag | (next_input == ATTN.END())
- if end_flag.all():
- break
-
- _, preds_index = probs.max(2)
-
- return preds_index, probs, None # batch_size x num_steps x num_classes
-
- def forward(self, beam_size, batch_H, text, batch_max_length, is_train=True, is_test=False):
- if is_train:
- return self.forward_greedy(batch_H, text, is_train, is_test, batch_max_length)
- else:
- if beam_size > 1:
- return self.forward_beam(batch_H, batch_max_length, beam_size)
- else:
- return self.forward_greedy(batch_H, text, is_train, is_test, batch_max_length)
-
diff --git a/spaces/dylanebert/gaussian-viewer/public/index.html b/spaces/dylanebert/gaussian-viewer/public/index.html
deleted file mode 100644
index e632cc9db931ec1a61a8aff7782544018e4c480e..0000000000000000000000000000000000000000
--- a/spaces/dylanebert/gaussian-viewer/public/index.html
+++ /dev/null
@@ -1,48 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Dallas Buyers Club Full Movie 720p HD Free [url= pawel4thgentabletair.pro [url= google maps 4 letter sorority zip code]download[/url] Noun fauna vega her latest trailer 2015 [url= movies stubbing/breaking [url= Dating Workbook for Teens License Full Version ВЂ“ TorrentDownload]Dating Workbook for Teens License Full Version ВЂ“ TorrentDownload[/url] GSM Cell Phone Battery Life [url= tododee azar-tangamu]azar-tangamu[/url] Embroidery Workshop [url= izabaschigi mahovshii 092 [url= izabaschigi mahovshii 04 [url= izabaschigi mahovshii 022030-1257 [url= 726th full version serial key [url= izabaschigi mahovshii 095 [url= izabaschigi mahovshii 042021-0220 [url= 332101-1252 [url= izabaschigi mahovshii 092 [url= bozza za x101 iMGSRC.RU [url=
[url= DAZ3D for 99! Free Download [url= [url= Desktop Calendar for Windows 8.1 Home Premium 64-bit Crack [url= Anatomy And Function Of Of High-Strength Materials[/url] jasoda man thanu free download[/url]
[url= frz2x32 [url= Customize desktop icons and colors[/url] free download[/url]
[url= zap5uq5iq ]zz2x32[/url]
[url= 1/2 year for[/url]
[url= [url= desktop calendar for windows 8.[/url] Hit Man 2 Speech Box/iMGSRC.RU/Guys 2 Suertods 6, iMGSRC.RU/Gym boys 10, DSC_0334 iMGSRC.RU [url= guys 2 Suertudos 2, 6 iMGSRC.RU/ Audionamix crack full download for 21 iMGSRC.RU/PATCHED Adobe Photoshop Lightroom CC 2018 8.1 Crack [url= briletypeAbumunult [url= 2004, DSC_2044 iMGSRC.RU [url= pia, E76A2D8B-279B-460B-ED iMGSRC.RU [url=
[url= [url=
The emperors new clothes free worksheets[/url] Taiseertaids [url= U 1st see info, E76A2D8B-3 iMGSRC.RU [url= apk free[/url]U 1st see info, E76A2D8B-3 iMGSRC.RU [url=
[url= Live Stream Online[/url]Holly, Z-cbR2OOHSI iMGSRC.RU [url=
Live Stream Online.
-Adobe Acrobat Pro DC 2018.011.20055 Full With Medicine[BabuPC] Serial Key
DOWNLOAD ❤ https://jinyurl.com/2uEpz1
899543212b
-
-
\ No newline at end of file
diff --git a/spaces/eradhea/spanish_chat/README.md b/spaces/eradhea/spanish_chat/README.md
deleted file mode 100644
index 7f90a04d957a30337dbf960cf4a04d6e6d12ecc9..0000000000000000000000000000000000000000
--- a/spaces/eradhea/spanish_chat/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Spanish Chat
-emoji: 🐨
-colorFrom: blue
-colorTo: red
-sdk: gradio
-sdk_version: 3.8.2
-app_file: app.py
-pinned: false
-license: gpl-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/eson/tokenizer-arena/vocab/gpt_neox_chinese_v1/to_v2/test_queue.py b/spaces/eson/tokenizer-arena/vocab/gpt_neox_chinese_v1/to_v2/test_queue.py
deleted file mode 100644
index 6662b9142e5fd8ec81994f53246e2b72de2ad1de..0000000000000000000000000000000000000000
--- a/spaces/eson/tokenizer-arena/vocab/gpt_neox_chinese_v1/to_v2/test_queue.py
+++ /dev/null
@@ -1,20 +0,0 @@
-
-from queue import Queue
-
-q = Queue(maxsize=0)
-
-#写入队列数据
-q.put(0)
-q.put(1)
-q.put(2)
-
-#输出当前队列所有数据
-print(q.queue)
-#删除队列数据，并返回该数据
-q.get()
-#输也所有队列数据
-print(q.queue)
-
-for i in range(10):
- print(q.get(), q.qsize())
-
diff --git "a/spaces/f2api/gpt-academic/crazy_functions/\346\200\273\347\273\223word\346\226\207\346\241\243.py" "b/spaces/f2api/gpt-academic/crazy_functions/\346\200\273\347\273\223word\346\226\207\346\241\243.py"
deleted file mode 100644
index eada69dc65587782125c0809381260a6bbdce225..0000000000000000000000000000000000000000
--- "a/spaces/f2api/gpt-academic/crazy_functions/\346\200\273\347\273\223word\346\226\207\346\241\243.py"
+++ /dev/null
@@ -1,127 +0,0 @@
-from toolbox import update_ui
-from toolbox import CatchException, report_execption, write_results_to_file
-from .crazy_utils import request_gpt_model_in_new_thread_with_ui_alive
-fast_debug = False
-
-
-def 解析docx(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt):
- import time, os
- # pip install python-docx 用于docx格式，跨平台
- # pip install pywin32 用于doc格式，仅支持Win平台
- for index, fp in enumerate(file_manifest):
- if fp.split(".")[-1] == "docx":
- from docx import Document
- doc = Document(fp)
- file_content = "\n".join([para.text for para in doc.paragraphs])
- else:
- import win32com.client
- word = win32com.client.Dispatch("Word.Application")
- word.visible = False
- # 打开文件
- print('fp', os.getcwd())
- doc = word.Documents.Open(os.getcwd() + '/' + fp)
- # file_content = doc.Content.Text
- doc = word.ActiveDocument
- file_content = doc.Range().Text
- doc.Close()
- word.Quit()
-
- print(file_content)
- # private_upload里面的文件名在解压zip后容易出现乱码（rar和7z格式正常），故可以只分析文章内容，不输入文件名
- from .crazy_utils import breakdown_txt_to_satisfy_token_limit_for_pdf
- from request_llm.bridge_all import model_info
- max_token = model_info[llm_kwargs['llm_model']]['max_token']
- TOKEN_LIMIT_PER_FRAGMENT = max_token * 3 // 4
- paper_fragments = breakdown_txt_to_satisfy_token_limit_for_pdf(
- txt=file_content,
- get_token_fn=model_info[llm_kwargs['llm_model']]['token_cnt'],
- limit=TOKEN_LIMIT_PER_FRAGMENT
- )
- this_paper_history = []
- for i, paper_frag in enumerate(paper_fragments):
- i_say = f'请对下面的文章片段用中文做概述，文件名是{os.path.relpath(fp, project_folder)}，文章内容是 ```{paper_frag}```'
- i_say_show_user = f'请对下面的文章片段做概述: {os.path.abspath(fp)}的第{i+1}/{len(paper_fragments)}个片段。'
- gpt_say = yield from request_gpt_model_in_new_thread_with_ui_alive(
- inputs=i_say,
- inputs_show_user=i_say_show_user,
- llm_kwargs=llm_kwargs,
- chatbot=chatbot,
- history=[],
- sys_prompt="总结文章。"
- )
-
- chatbot[-1] = (i_say_show_user, gpt_say)
- history.extend([i_say_show_user,gpt_say])
- this_paper_history.extend([i_say_show_user,gpt_say])
-
- # 已经对该文章的所有片段总结完毕，如果文章被切分了，
- if len(paper_fragments) > 1:
- i_say = f"根据以上的对话，总结文章{os.path.abspath(fp)}的主要内容。"
- gpt_say = yield from request_gpt_model_in_new_thread_with_ui_alive(
- inputs=i_say,
- inputs_show_user=i_say,
- llm_kwargs=llm_kwargs,
- chatbot=chatbot,
- history=this_paper_history,
- sys_prompt="总结文章。"
- )
-
- history.extend([i_say,gpt_say])
- this_paper_history.extend([i_say,gpt_say])
-
- res = write_results_to_file(history)
- chatbot.append(("完成了吗？", res))
- yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-
- res = write_results_to_file(history)
- chatbot.append(("所有文件都总结完成了吗？", res))
- yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-
-
-@CatchException
-def 总结word文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
- import glob, os
-
- # 基本信息：功能、贡献者
- chatbot.append([
- "函数插件功能？",
- "批量总结Word文档。函数插件贡献者: JasonGuo1。注意, 如果是.doc文件, 请先转化为.docx格式。"])
- yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-
- # 尝试导入依赖，如果缺少依赖，则给出安装建议
- try:
- from docx import Document
- except:
- report_execption(chatbot, history,
- a=f"解析项目: {txt}",
- b=f"导入软件依赖失败。使用该模块需要额外依赖，安装方法```pip install --upgrade python-docx pywin32```。")
- yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
- return
-
- # 清空历史，以免输入溢出
- history = []
-
- # 检测输入参数，如没有给定输入参数，直接退出
- if os.path.exists(txt):
- project_folder = txt
- else:
- if txt == "": txt = '空空如也的输入栏'
- report_execption(chatbot, history, a=f"解析项目: {txt}", b=f"找不到本地项目或无权访问: {txt}")
- yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
- return
-
- # 搜索需要处理的文件清单
- if txt.endswith('.docx') or txt.endswith('.doc'):
- file_manifest = [txt]
- else:
- file_manifest = [f for f in glob.glob(f'{project_folder}/**/*.docx', recursive=True)] + \
- [f for f in glob.glob(f'{project_folder}/**/*.doc', recursive=True)]
-
- # 如果没找到任何文件
- if len(file_manifest) == 0:
- report_execption(chatbot, history, a=f"解析项目: {txt}", b=f"找不到任何.docx或doc文件: {txt}")
- yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
- return
-
- # 开始正式执行任务
- yield from 解析docx(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt)
diff --git a/spaces/facebook/ov-seg/open_vocab_seg/modeling/matcher.py b/spaces/facebook/ov-seg/open_vocab_seg/modeling/matcher.py
deleted file mode 100644
index a72ba671ad60db078e08046357a6aa0e5e9bd5dc..0000000000000000000000000000000000000000
--- a/spaces/facebook/ov-seg/open_vocab_seg/modeling/matcher.py
+++ /dev/null
@@ -1,187 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-# Modified by Bowen Cheng from https://github.com/facebookresearch/detr/blob/master/models/matcher.py
-# Copyright (c) Meta Platforms, Inc. All Rights Reserved
-
-"""
-Modules to compute the matching cost and solve the corresponding LSAP.
-"""
-import torch
-import torch.nn.functional as F
-from scipy.optimize import linear_sum_assignment
-from torch import nn
-
-
-def batch_dice_loss(inputs, targets):
- """
- Compute the DICE loss, similar to generalized IOU for masks
- Args:
- inputs: A float tensor of arbitrary shape.
- The predictions for each example.
- targets: A float tensor with the same shape as inputs. Stores the binary
- classification label for each element in inputs
- (0 for the negative class and 1 for the positive class).
- """
- inputs = inputs.sigmoid()
- inputs = inputs.flatten(1)
- numerator = 2 * torch.einsum("nc,mc->nm", inputs, targets)
- denominator = inputs.sum(-1)[:, None] + targets.sum(-1)[None, :]
- loss = 1 - (numerator + 1) / (denominator + 1)
- return loss
-
-
-def batch_sigmoid_focal_loss(inputs, targets, alpha: float = 0.25, gamma: float = 2):
- """
- Loss used in RetinaNet for dense detection: https://arxiv.org/abs/1708.02002.
- Args:
- inputs: A float tensor of arbitrary shape.
- The predictions for each example.
- targets: A float tensor with the same shape as inputs. Stores the binary
- classification label for each element in inputs
- (0 for the negative class and 1 for the positive class).
- alpha: (optional) Weighting factor in range (0,1) to balance
- positive vs negative examples. Default = -1 (no weighting).
- gamma: Exponent of the modulating factor (1 - p_t) to
- balance easy vs hard examples.
- Returns:
- Loss tensor
- """
- hw = inputs.shape[1]
-
- prob = inputs.sigmoid()
- focal_pos = ((1 - prob) ** gamma) * F.binary_cross_entropy_with_logits(
- inputs, torch.ones_like(inputs), reduction="none"
- )
- focal_neg = (prob ** gamma) * F.binary_cross_entropy_with_logits(
- inputs, torch.zeros_like(inputs), reduction="none"
- )
- if alpha >= 0:
- focal_pos = focal_pos * alpha
- focal_neg = focal_neg * (1 - alpha)
-
- loss = torch.einsum("nc,mc->nm", focal_pos, targets) + torch.einsum(
- "nc,mc->nm", focal_neg, (1 - targets)
- )
-
- return loss / hw
-
-
-class HungarianMatcher(nn.Module):
- """This class computes an assignment between the targets and the predictions of the network
-
- For efficiency reasons, the targets don't include the no_object. Because of this, in general,
- there are more predictions than targets. In this case, we do a 1-to-1 matching of the best predictions,
- while the others are un-matched (and thus treated as non-objects).
- """
-
- def __init__(
- self, cost_class: float = 1, cost_mask: float = 1, cost_dice: float = 1
- ):
- """Creates the matcher
-
- Params:
- cost_class: This is the relative weight of the classification error in the matching cost
- cost_mask: This is the relative weight of the focal loss of the binary mask in the matching cost
- cost_dice: This is the relative weight of the dice loss of the binary mask in the matching cost
- """
- super().__init__()
- self.cost_class = cost_class
- self.cost_mask = cost_mask
- self.cost_dice = cost_dice
- assert (
- cost_class != 0 or cost_mask != 0 or cost_dice != 0
- ), "all costs cant be 0"
-
- @torch.no_grad()
- def memory_efficient_forward(self, outputs, targets):
- """More memory-friendly matching"""
- bs, num_queries = outputs["pred_logits"].shape[:2]
-
- # Work out the mask padding size
- masks = [v["masks"] for v in targets]
- h_max = max([m.shape[1] for m in masks])
- w_max = max([m.shape[2] for m in masks])
-
- indices = []
-
- # Iterate through batch size
- for b in range(bs):
-
- out_prob = outputs["pred_logits"][b].softmax(
- -1
- ) # [num_queries, num_classes]
- out_mask = outputs["pred_masks"][b] # [num_queries, H_pred, W_pred]
-
- tgt_ids = targets[b]["labels"]
- # gt masks are already padded when preparing target
- tgt_mask = targets[b]["masks"].to(out_mask)
-
- # Compute the classification cost. Contrary to the loss, we don't use the NLL,
- # but approximate it in 1 - proba[target class].
- # The 1 is a constant that doesn't change the matching, it can be ommitted.
- cost_class = -out_prob[:, tgt_ids]
-
- # Downsample gt masks to save memory
- tgt_mask = F.interpolate(
- tgt_mask[:, None], size=out_mask.shape[-2:], mode="nearest"
- )
-
- # Flatten spatial dimension
- out_mask = out_mask.flatten(1) # [batch_size * num_queries, H*W]
- tgt_mask = tgt_mask[:, 0].flatten(1) # [num_total_targets, H*W]
-
- # Compute the focal loss between masks
- cost_mask = batch_sigmoid_focal_loss(out_mask, tgt_mask)
-
- # Compute the dice loss betwen masks
- cost_dice = batch_dice_loss(out_mask, tgt_mask)
-
- # Final cost matrix
- C = (
- self.cost_mask * cost_mask
- + self.cost_class * cost_class
- + self.cost_dice * cost_dice
- )
- C = C.reshape(num_queries, -1).cpu()
-
- indices.append(linear_sum_assignment(C))
- return [
- (
- torch.as_tensor(i, dtype=torch.int64),
- torch.as_tensor(j, dtype=torch.int64),
- )
- for i, j in indices
- ]
-
- @torch.no_grad()
- def forward(self, outputs, targets):
- """Performs the matching
-
- Params:
- outputs: This is a dict that contains at least these entries:
- "pred_logits": Tensor of dim [batch_size, num_queries, num_classes] with the classification logits
- "pred_masks": Tensor of dim [batch_size, num_queries, H_pred, W_pred] with the predicted masks
-
- targets: This is a list of targets (len(targets) = batch_size), where each target is a dict containing:
- "labels": Tensor of dim [num_target_boxes] (where num_target_boxes is the number of ground-truth
- objects in the target) containing the class labels
- "masks": Tensor of dim [num_target_boxes, H_gt, W_gt] containing the target masks
-
- Returns:
- A list of size batch_size, containing tuples of (index_i, index_j) where:
- - index_i is the indices of the selected predictions (in order)
- - index_j is the indices of the corresponding selected targets (in order)
- For each batch element, it holds:
- len(index_i) = len(index_j) = min(num_queries, num_target_boxes)
- """
- return self.memory_efficient_forward(outputs, targets)
-
- def __repr__(self):
- head = "Matcher " + self.__class__.__name__
- body = [
- "cost_class: {}".format(self.cost_class),
- "cost_mask: {}".format(self.cost_mask),
- "cost_dice: {}".format(self.cost_dice),
- ]
- _repr_indent = 4
- lines = [head] + [" " * _repr_indent + line for line in body]
- return "\n".join(lines)
diff --git a/spaces/falcondai/code-as-policies/LICENSE.md b/spaces/falcondai/code-as-policies/LICENSE.md
deleted file mode 100644
index 2697cde25676d46a917a2d9362dd0e5495b6d2ca..0000000000000000000000000000000000000000
--- a/spaces/falcondai/code-as-policies/LICENSE.md
+++ /dev/null
@@ -1,7 +0,0 @@
-Copyright 2021 Google LLC. SPDX-License-Identifier: Apache-2.0
-
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
-
-https://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
\ No newline at end of file
diff --git a/spaces/falterWliame/Face_Mask_Detection/Fiind Baiet Paduri Cutreieram De Mihai Eminescu Comentariu Literar.md b/spaces/falterWliame/Face_Mask_Detection/Fiind Baiet Paduri Cutreieram De Mihai Eminescu Comentariu Literar.md
deleted file mode 100644
index 25e50fbad9187fab6205a28d95e7fb837a06e145..0000000000000000000000000000000000000000
--- a/spaces/falterWliame/Face_Mask_Detection/Fiind Baiet Paduri Cutreieram De Mihai Eminescu Comentariu Literar.md
+++ /dev/null
@@ -1,10 +0,0 @@
-
-fiind baiet paduri cutreieram de mihai eminescu comentariu literar.
. image with caption: download: fiind baiet paduri cutreieram de mihai eminescu comentariu literar. mihai eminescu. thus the stems of the title are: mihai eminescu eminescu. . mihai eminescu s-a nascut in.
-fiind baiet paduri cutreieram de mihai eminescu comentariu literar
DOWNLOAD … https://urlca.com/2uDdyk
-fiind baiet paduri cutreieram de mihai eminescu#eminescu #recitalpoezii #poeziiaudio interpretare: eduard ghergheluca. of william wordsworth and of mihai eminescu, they have many views and. fiind biet pduri cutreieram/ i m culcam ades lng izvor,/ iar braul drept.
-serpent-rocks-1.3.09.tar.gz 2011-06-18 10:54 2.1m [ ]. acrobot 3.3 full.zip.. fiind baiet paduri cutreieram de mihai eminescu comentariu literar. fiind biet pduri cutreieram, de mihai eminescu (comentariu literar,. precum i la figuri de stil i motive literare care compun.
-download download (mirror #1)
fiind baiet paduri cutreieram de mihai eminescu comentariu literar
about i want to write a book, but my english is not good, so i have to translate it from spanish to english.
i am going to make some translation for a book, but my english is not good, so i have to translate it from spanish to english.. material, diacritics, punctuation, hyphens and word order are taken into account. another important issue is if the source material has a capital letter at the beginning of each of the title, chapter, and page numbers.
-
- -mihai-eminescu-comentariu-literar-link.. mihai eminescu. thus the stems of the title are: mihai eminescu eminescu. how to correctly choose a name for your novel or short story: a guide for writers in english, french, spanish, german and portuguese. i've seen some of my friends posting novels and short stories on facebook. buying a novel or short story in english is a great way to see if the. the main thing in writing a novel or short story in english is the title. find the best and highest rated books online and download book pdf. mobile books and ebook reader apps for android. to keep the legacy of the great romanian writer mihai eminescu alive. download or read mihai eminescu in english pdf online. in this guide, we'll teach you how to write a novel, short story, essay or any other kind of creative writing in english. we'll look at all the stages of the creative process and how to avoid the pitfalls. fiind baiet paduri cutreieram de mihai eminescu comentariu literar. hi, i'm mihai, and i'm a writer in the english language.
899543212b
-
-
\ No newline at end of file
diff --git a/spaces/fatiXbelha/sd/Cmo jugar a Arena Breakout APK en Android Gua completa.md b/spaces/fatiXbelha/sd/Cmo jugar a Arena Breakout APK en Android Gua completa.md
deleted file mode 100644
index 1d8f451ec939dff6da2fa7a9b304d0594df939ca..0000000000000000000000000000000000000000
--- a/spaces/fatiXbelha/sd/Cmo jugar a Arena Breakout APK en Android Gua completa.md
+++ /dev/null
@@ -1,146 +0,0 @@
-
-Arena Breakout APK: Un juego de acción y supervivencia para Android
-¿Te gustan los juegos de disparos en primera persona? ¿Quieres vivir una experiencia de combate intensa y emocionante en tu dispositivo móvil? Si la respuesta es sí, entonces te presentamos Arena Breakout APK, un juego de acción y supervivencia para Android que te pondrá a prueba en diferentes escenarios y modos de juego. En este artículo, te contaremos todo lo que necesitas saber sobre este juego, sus características principales, cómo descargarlo e instalarlo en tu dispositivo Android, sus ventajas y desventajas, y algunas preguntas frecuentes que te pueden interesar.
-arena breakout apk para android
Download File ✯ https://urllie.com/2uNzaQ
-¿Qué es Arena Breakout APK?
-Arena Breakout APK es un juego de acción y supervivencia para Android desarrollado por Tencent Games, una de las compañías más importantes del sector de los videojuegos. Se trata de un juego que combina elementos de los géneros shooter, battle royale, y survival, ofreciendo una experiencia de juego dinámica, divertida, y competitiva. En el juego, tendrás que elegir un personaje entre varias categorías, como aviones de ataque, francotiradores, paramédicos, etc., y equiparlo con armas, accesorios, y habilidades especiales. Luego, tendrás que enfrentarte a otros jugadores en diferentes modos de juego, como deathmatch, team deathmatch, capture the flag, etc., en diferentes mapas ambientados en zonas urbanas, rurales, o industriales. El objetivo es sobrevivir el mayor tiempo posible, eliminar a tus enemigos, y conseguir la mayor puntuación. Además, el juego cuenta con un sistema de clasificación y recompensas que te permitirá desbloquear nuevos elementos para tu personaje y mejorar tus habilidades.
-Características principales de Arena Breakout APK
-Arena Breakout APK es un juego que destaca por sus múltiples características que lo hacen atractivo y entretenido para los amantes de los juegos de acción y supervivencia. Algunas de estas características son:
-Gráficos impresionantes y realistas
-El juego cuenta con unos gráficos de alta calidad que te harán sentir como si estuvieras dentro del juego. Los escenarios son detallados y variados, con efectos de luz, sombra, y partículas que le dan un toque de realismo. Los personajes y las armas también están bien diseñados y animados, con expresiones faciales, movimientos fluidos, y sonidos auténticos. El juego tiene una buena optimización que hace que funcione sin problemas en la mayoría de los dispositivos Android.
-Modos de juego variados y desafiantes
-El juego ofrece varios modos de juego que se adaptan a los gustos y preferencias de cada jugador. Puedes jugar solo o con tus amigos en partidas online o locales. Algunos de los modos de juego disponibles son:
-
-- Deathmatch: Un modo clásico donde tienes que eliminar al mayor número posible de enemigos en un tiempo limitado.
-- Team deathmatch: Un modo similar al anterior pero en equipos. Tienes que cooperar con tus aliados para derrotar al equipo rival.
-- Capture the flag: Un modo donde tienes que capturar la bandera del equipo enemigo y llevarla a tu base, mientras evitas que el equipo contrario haga lo mismo con la tuya.
-- Survival: Un modo donde tienes que sobrevivir el mayor tiempo posible en un mapa lleno de zombis y otros peligros. Puedes usar armas, vehículos, y objetos para defenderte y escapar.
-
-Personajes personalizables y equipables
-El juego te permite elegir entre varios personajes que pertenecen a diferentes categorías, como aviones de ataque, francotiradores, paramédicos, etc. Cada personaje tiene sus propias características, habilidades, y ventajas que lo hacen único y especial. Además, puedes personalizar el aspecto de tu personaje con diferentes trajes, accesorios, y gestos. También puedes equipar a tu personaje con diferentes armas, como pistolas, rifles, escopetas, lanzagranadas, etc., que puedes mejorar y modificar con diferentes accesorios, como miras, silenciadores, cargadores, etc.
-arena breakout apk download free for android
-arena breakout apk latest version 2023
-arena breakout apk gratis en español
-arena breakout apk mod unlimited money
-arena breakout apk offline no internet
-arena breakout apk obb data file
-arena breakout apk hack cheats tool
-arena breakout apk review gameplay video
-arena breakout apk update new features
-arena breakout apk beta test sign up
-arena breakout apk Tencent Games official website
-arena breakout apk Level Infinite developer
-arena breakout apk 暗区突围 Chinese version
-arena breakout apk action FPS game genre
-arena breakout apk tactical shooter challenge
-arena breakout apk multiplayer online mode
-arena breakout apk solo campaign mode
-arena breakout apk co-op team mode
-arena breakout apk custom match mode
-arena breakout apk ranked match mode
-arena breakout apk battle royale mode
-arena breakout apk survival mode
-arena breakout apk zombie mode
-arena breakout apk deathmatch mode
-arena breakout apk capture the flag mode
-arena breakout apk bomb defuse mode
-arena breakout apk hostage rescue mode
-arena breakout apk domination mode
-arena breakout apk team deathmatch mode
-arena breakout apk search and destroy mode
-arena breakout apk gun game mode
-arena breakout apk free for all mode
-arena breakout apk training mode tutorial
-arena breakout apk weapons list guide
-arena breakout apk characters list guide
-arena breakout apk skins list guide
-arena breakout apk maps list guide
-arena breakout apk tips tricks secrets
-arena breakout apk best settings options
-arena breakout apk system requirements specs
-arena breakout apk compatible devices models
-arena breakout apk how to install instructions
-arena breakout apk how to play guide
-arena breakout apk how to win strategy
-arena breakout apk how to get free coins gems diamonds gold cash money currency rewards points vouchers coupons codes gift cards giveaways prizes bonuses rewards items resources materials equipment accessories outfits costumes weapons characters skins maps modes features updates patches fixes bugs glitches errors problems issues solutions fixes tips tricks secrets hacks cheats mods tools apps bots hacks generators injectors surveys verification human verification no verification no survey no root no jailbreak no password no email required needed necessary download install play enjoy fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun.
-Sistema de clasificación y recompensas
-El juego cuenta con un sistema de clasificación que te permite medir tu nivel y habilidad en comparación con otros jugadores. A medida que juegas y ganas partidas, obtienes puntos de experiencia y monedas que te permiten subir de nivel y desbloquear nuevos elementos para tu personaje. También puedes obtener recompensas especiales al completar misiones diarias y semanales, o al participar en eventos temporales. Estas recompensas pueden incluir trajes exclusivos, armas legendarias, cajas sorpresa, etc.
-¿Cómo descargar e instalar Arena Breakout APK en tu dispositivo Android?
-Arena Breakout APK es un juego que no está disponible en la tienda oficial de Google Play, por lo que tendrás que descargarlo e instalarlo manualmente desde una fuente externa. Para ello, tendrás que seguir los siguientes pasos:
-Requisitos mínimos del sistema
-Antes de descargar e instalar el juego, asegúrate de que tu dispositivo Android cumpla con los requisitos mínimos del sistema para poder ejecutarlo correctamente. Estos requisitos son:
-
-- Sistema operativo: Android 5.0 o superior
-- Memoria RAM: 2 GB o más
-- Espacio de almacenamiento: 1 GB o más
-- Conexión a internet: Wi-Fi o datos móviles
-
-Pasos para descargar e instalar Arena Breakout APK
-Una vez que hayas comprobado los requisitos del sistema, sigue estos pasos para descargar e instalar el juego en tu dispositivo Android:
-
-- Entra en el navegador web de tu dispositivo y busca el archivo APK de Arena Breakout. Puedes usar el siguiente enlace para descargarlo directamente: [Arena Breakout APK].
-- Descarga el archivo APK en tu dispositivo y espera a que se complete la descarga.
-- Antes de instalar el archivo APK, tendrás que habilitar la opción de "Orígenes desconocidos" en tu dispositivo. Para ello, ve a Ajustes > Seguridad > Orígenes desconocidos y activa la casilla correspondiente.
-- Busca el archivo APK descargado en la carpeta de descargas de tu dispositivo y ábrelo.
-- Sigue las instrucciones que aparecen en la pantalla para instalar el juego.
-- Una vez instalado el juego, podrás abrirlo desde el menú de aplicaciones de tu dispositivo y disfrutar de Arena Breakout APK.
-
Ventajas y desventajas de Arena Breakout APK
-Como todo juego, Arena Breakout APK tiene sus ventajas y desventajas que debes conocer antes de descargarlo e instalarlo en tu dispositivo Android. A continuación, te las resumimos en una tabla comparativa:
-
-
-Ventajas
-Desventajas
-
-
-Es un juego gratuito y sin anuncios.
-Requiere una conexión a internet constante para jugar.
-
-
-Es un juego divertido y adictivo que te ofrece horas de entretenimiento.
-Puede consumir mucha batería y recursos de tu dispositivo.
-
-
-Es un juego con una gran variedad de modos de juego, personajes, armas, y escenarios.
-Puede presentar algunos errores o fallos técnicos en algunos dispositivos.
-
-
-Es un juego con unos gráficos impresionantes y realistas que te harán sentir como si estuvieras en el juego.
-No está disponible en la tienda oficial de Google Play y hay que descargarlo e instalarlo manualmente.
-
-
-Es un juego con un sistema de clasificación y recompensas que te motiva a mejorar y competir con otros jugadores.
-No tiene un modo de juego offline o sin conexión a internet.
-
-
- Conclusión
-Arena Breakout APK es un juego de acción y supervivencia para Android que te ofrece una experiencia de juego única y emocionante. Podrás elegir entre varios personajes, armas, y modos de juego, y enfrentarte a otros jugadores en diferentes escenarios. El juego cuenta con unos gráficos impresionantes y realistas, un sistema de clasificación y recompensas, y una jugabilidad fluida y dinámica. Si te gustan los juegos de disparos en primera persona, no dudes en descargar e instalar Arena Breakout APK en tu dispositivo Android y disfrutar de este juego increíble.
- Preguntas frecuentes sobre Arena Breakout APK
- A continuación, te presentamos algunas preguntas frecuentes que te pueden interesar sobre Arena Breakout APK:
- ¿Es seguro descargar e instalar Arena Breakout APK?
- Sí, es seguro descargar e instalar Arena Breakout APK siempre que lo hagas desde una fuente confiable y sigas los pasos que te hemos indicado anteriormente. El archivo APK está libre de virus, malware, o cualquier otro tipo de amenaza para tu dispositivo. Sin embargo, te recomendamos que tengas un antivirus instalado en tu dispositivo por si acaso.
- ¿Es legal descargar e instalar Arena Breakout APK?
- Sí, es legal descargar e instalar Arena Breakout APK siempre que lo hagas para uso personal y no comercial. El juego es propiedad de Tencent Games, una compañía que tiene los derechos legales sobre el mismo. Sin embargo, al no estar disponible en la tienda oficial de Google Play, el juego no cuenta con el respaldo ni la garantía de Google. Por lo tanto, descarga e instala el juego bajo tu propia responsabilidad.
- ¿Qué hacer si el juego no funciona correctamente o se cierra inesperadamente?
- Si el juego no funciona correctamente o se cierra inesperadamente, puede deberse a varias razones, como una mala conexión a internet, un dispositivo incompatible, una falta de espacio de almacenamiento, o un error del juego. Para solucionar este problema, puedes intentar lo siguiente:
-
-- Verifica que tu conexión a internet sea estable y rápida.
-- Asegúrate de que tu dispositivo cumpla con los requisitos mínimos del sistema para ejecutar el juego.
-- Limpia la caché y los datos del juego desde los ajustes de tu dispositivo.
-- Reinicia tu dispositivo y vuelve a abrir el juego.
-- Desinstala el juego y vuelve a instalarlo siguiendo los pasos que te hemos indicado anteriormente.
-- Contacta con el servicio de atención al cliente del juego si el problema persiste.
-
- ¿Cómo actualizar Arena Breakout APK?
- Para actualizar Arena Breakout APK, tendrás que seguir los mismos pasos que para descargarlo e instalarlo. Es decir, tendrás que buscar el archivo APK de la última versión del juego en el navegador web de tu dispositivo y descargarlo. Luego, tendrás que abrir el archivo APK descargado y seguir las instrucciones que aparecen en la pantalla para instalar la nueva versión del juego. Recuerda que antes de instalar el archivo APK, tendrás que habilitar la opción de "Orígenes desconocidos" en tu dispositivo. También puedes borrar la versión anterior del juego si quieres liberar espacio de almacenamiento.
- ¿Cómo jugar con amigos a Arena Breakout APK?
- Para jugar con amigos a Arena Breakout APK, tendrás que seguir los siguientes pasos:
-
-- Abre el juego desde el menú de aplicaciones de tu dispositivo.
-- En la pantalla principal, toca el icono de "Amigos" en la esquina superior derecha.
-- En la pantalla de "Amigos", podrás ver la lista de tus amigos que también juegan a Arena Breakout APK. Si quieres añadir a un nuevo amigo, toca el icono de "Añadir amigo" en la esquina superior derecha e introduce su nombre de usuario o su código QR.
-- Para invitar a un amigo a jugar contigo, toca su nombre en la lista y luego toca el botón de "Invitar". Tu amigo recibirá una notificación y podrá aceptar o rechazar tu invitación.
-- Una vez que tu amigo acepte tu invitación, podrás verlo en tu equipo y podrás elegir el modo de juego y el mapa que quieras jugar. Luego, toca el botón de "Empezar" para iniciar la partida.
-- Disfruta de jugar con tu amigo a Arena Breakout APK.
-
197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/fatiXbelha/sd/Download Live Your Life by Joeboy - A Soulful Song to Inspire You.md b/spaces/fatiXbelha/sd/Download Live Your Life by Joeboy - A Soulful Song to Inspire You.md
deleted file mode 100644
index 1df25f32cbbd270b2818ff09f0bb89cf5a61a77a..0000000000000000000000000000000000000000
--- a/spaces/fatiXbelha/sd/Download Live Your Life by Joeboy - A Soulful Song to Inspire You.md
+++ /dev/null
@@ -1,130 +0,0 @@
-
-How to Download Joeboy Live Your Life and Enjoy His Music
-If you are a fan of Nigerian music, you may have heard of Joeboy, a talented singer and songwriter who has been making waves in the industry. His latest song, Live Your Life, is a collaboration with MTN Pulse, a mobile service that offers affordable data plans and music streaming. In this article, we will tell you more about Joeboy, his new song, and how you can download it from different sources.
-download joeboy live your life
DOWNLOAD > https://urllie.com/2uNFLE
-Who is Joeboy and What is Live Your Life?
-Joeboy's Biography and Music Career
-Joeboy, whose real name is Joseph Akinwale Akinfenwa, was born on May 21, 1997, in Lagos, Nigeria. He grew up in a musical family and started singing at a young age. He studied human resource management at the University of Lagos and graduated in 2019.
-Joeboy's music career took off in 2017, when he recorded a cover of Ed Sheeran's Shape of You and uploaded it to SoundCloud. The song caught the attention of Mr Eazi, a Nigerian superstar and founder of emPawa Africa, a talent incubator for African artists. Mr Eazi became Joeboy's mentor and helped him launch his debut single, Baby, in 2019. The song was a huge hit and has over 40 million streams on YouTube.
-Since then, Joeboy has released several other songs, such as Beginning, Don't Call Me Back, All for You, Call, Lonely, Focus, and Show Me. He has also collaborated with other artists, such as DJ Neptune, Major Lazer, Kwesi Arthur, Rayvanny, and E Kelly. He has won several awards, such as Best Artiste in African Pop at the All Africa Music Awards (AFRIMA) in 2019 and Best Pop at the Soundcity MVP Awards Festival in 2020.
-Live Your Life: A New Song by Joeboy and MTN Pulse
-Live Your Life is a new song by Joeboy that was released in December 2022. It is part of a partnership between Joeboy and MTN Pulse, a mobile service that offers affordable data plans and music streaming for young people. The song is an upbeat and inspirational tune that encourages listeners to live their lives to the fullest and enjoy every moment.
-The song was produced by Killertunes, a Nigerian producer who has worked with artists such as Wizkid, Tiwa Savage, Olamide, and Naira Marley. The song features catchy lyrics, such as \"Live your life like you want it / Don't let nobody tell you nothing / You're the boss of your own life / So live it like you own it\". The song also has a catchy chorus that goes \"Live your life / Live your life / Live your life / Live your life / Live your life / Live your life\".
-download joeboy live your life lyrics
-download joeboy live your life mp3
-download joeboy live your life video
-download joeboy live your life song
-download joeboy live your life audio
-download joeboy live your life ft mtn pulse
-download joeboy live your life music
-download joeboy live your life youtube
-download joeboy live your life free
-download joeboy live your life remix
-download joeboy live your life album
-download joeboy live your life instrumental
-download joeboy live your life official video
-download joeboy live your life by lyrics lounge
-download joeboy live your life 2023
-download joeboy live your life mp4
-download joeboy live your life spotify
-download joeboy live your life soundcloud
-download joeboy live your life naijaloaded
-download joeboy live your life tooxclusive
-download joeboy live your life justnaija
-download joeboy live your life 9jaflaver
-download joeboy live your life waploaded
-download joeboy live your life genius
-download joeboy live your life azlyrics
-download joeboy live your life apple music
-download joeboy live your life amazon music
-download joeboy live your life deezer
-download joeboy live your life tidal
-download joeboy live your life audiomack
-download joeboy live your life fakaza
-download joeboy live your life zamusic
-download joeboy live your life hiphopza
-download joeboy live your life sahiphopmag
-download joeboy live your life flexyjamz
-download joeboy live your life hitvibes
-download joeboy live your life afrobeat360
-download joeboy live your life notjustok
-download joeboy live your life jaguda
-download joeboy live your life 360nobs
-Why You Should Download Joeboy Live Your Life
-The Benefits of Downloading Music
-Downloading music is a great way to enjoy your favorite songs anytime and anywhere. By downloading music, you can:
-
-- Save data and money. Streaming music online can consume a lot of data and cost you money if you don't have an unlimited plan. By downloading music offline, you can save data and money and listen to music without interruptions.
-- Create playlists and mixtapes. Downloading music allows you to create playlists and mixtapes of your favorite songs. You can customize your playlists according to your mood, genre, artist, or occasion. You -
- Enjoy music offline. Downloading music allows you to enjoy music offline, even when you don't have internet access or network coverage. You can listen to music on your device, such as your phone, tablet, laptop, or MP3 player, without worrying about connectivity issues.
-
-The Features of Joeboy Live Your Life
-Joeboy Live Your Life is a song that you should download and add to your music collection. Here are some of the features of the song that make it worth downloading:
-
-- It is a motivational and uplifting song. Joeboy Live Your Life is a song that inspires you to live your life to the fullest and enjoy every moment. It is a song that boosts your mood and energy and makes you feel positive and optimistic.
-- It is a catchy and danceable song. Joeboy Live Your Life is a song that has a catchy melody and rhythm that make you want to dance and sing along. It is a song that is suitable for parties, clubs, or any occasion where you want to have fun and groove.
-- It is a high-quality and original song. Joeboy Live Your Life is a song that showcases Joeboy's talent and creativity as a singer and songwriter. It is a song that has high-quality production and sound, as well as original lyrics and style. It is a song that stands out from the crowd and reflects Joeboy's personality and vision.
-
-How to Download Joeboy Live Your Life from Different Sources
-How to Download from YouTube
-One of the sources where you can download Joeboy Live Your Life is YouTube, the popular video-sharing platform. Here are the steps to download the song from YouTube:
-
-- Go to YouTube.com and search for Joeboy Live Your Life.
-- Select the video that has the official audio or video of the song.
-- Copy the URL of the video from the address bar of your browser.
-- Go to a YouTube to MP3 converter website, such as ytmp3.cc, y2mate.com, or flvto.biz.
-- Paste the URL of the video into the input box of the converter website.
-- Select MP3 as the output format and click on Convert or Download.
-- Wait for the conversion process to finish and then click on Download or Save to download the MP3 file of the song to your device.
-
-How to Download from iTunes
-Another source where you can download Joeboy Live Your Life is iTunes, the popular music store and player by Apple. Here are the steps to download the song from iTunes:
-
-- Go to iTunes.com and download and install the iTunes software on your device, if you don't have it already.
-- Launch iTunes and sign in with your Apple ID, or create one if you don't have one already.
-- Go to the iTunes Store and search for Joeboy Live Your Life.
-- Select the song from the results and click on Buy Song or Buy Album, depending on whether you want to buy only the song or the whole album that contains it.
-- Enter your payment details and confirm your purchase.
-- Wait for the download process to finish and then go to your Library to find and play the song on your device.
-
-How to Download from Google Play Music
-A third source where you can download Joeboy Live Your Life is Google Play Music, the popular music store and player by Google. Here are the steps to download the song from Google Play Music:
-
-- Go to play.google.com/music and sign in with your Google account, or create one if you don't have one already.
-- Go to the Music section and search for Joeboy Live Your Life.
-- Select the song from the results and click on Buy or Subscribe, depending on whether you want to buy only the song or subscribe to Google Play Music Unlimited, which gives you access to millions of songs for a monthly fee.
-- Enter your payment details and confirm your purchase or subscription.
-- Wait for the download process to finish and then go to your Library to find and play the song on your device.
-
- Conclusion and FAQs
- Summary of the Main Points
- In conclusion, Joeboy Live Your Life is a new song by Joeboy that was released in December 2022. It is a collaboration with MTN Pulse, a mobile service that offers affordable data plans and music streaming for young people. The song is an upbeat and inspirational tune that encourages listeners to live their lives to the fullest and - enjoy every moment. The song has many benefits and features that make it worth downloading, such as being motivational, catchy, danceable, high-quality, and original. You can download the song from different sources, such as YouTube, iTunes, and Google Play Music, by following the steps we have provided in this article. We hope you have learned something new and useful from this article and that you will download Joeboy Live Your Life and enjoy his music.
-FAQs
-Here are some of the frequently asked questions (FAQs) about Joeboy Live Your Life and their answers:
-
-
-Question
-Answer
-
-
-Where can I listen to Joeboy Live Your Life online?
-You can listen to Joeboy Live Your Life online on platforms such as YouTube, Spotify, Apple Music, Deezer, Boomplay, Audiomack, and SoundCloud.
-
-
-What is the genre of Joeboy Live Your Life?
-Joeboy Live Your Life is a pop song with influences from afrobeat, dancehall, and R&B.
-
-
-What is the duration of Joeboy Live Your Life?
-Joeboy Live Your Life is 3 minutes and 15 seconds long.
-
-
-What is the album that contains Joeboy Live Your Life?
-Joeboy Live Your Life is not part of any album yet. It is a single that was released independently by Joeboy and MTN Pulse.
-
-
-What are some of the other songs by Joeboy that I should check out?
-Some of the other songs by Joeboy that you should check out are Baby, Beginning, Don't Call Me Back, All for You, Call, Lonely, Focus, Show Me, Nobody (with DJ Neptune and Mr Eazi), Door (with Kwesi Arthur), and Bounce (with Major Lazer).
-
-
197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/fclong/summary/fengshen/examples/summary/pretrain_bart_summary.sh b/spaces/fclong/summary/fengshen/examples/summary/pretrain_bart_summary.sh
deleted file mode 100644
index f8a6af24f935cc563891922b8a50cd293231367b..0000000000000000000000000000000000000000
--- a/spaces/fclong/summary/fengshen/examples/summary/pretrain_bart_summary.sh
+++ /dev/null
@@ -1,124 +0,0 @@
-#!/bin/bash
-#SBATCH --job-name=bart_summary
-#SBATCH --nodes=1
-#SBATCH --ntasks-per-node=4
-#SBATCH --gres=gpu:4 # number of gpus
-#SBATCH -o %x-%j.log
-
-set -x -e
-
-echo "START TIME: $(date)"
-MODEL_NAME=bart-base
-MICRO_BATCH_SIZE=16
-ROOT_DIR=/cognitive_comp/dongxiaoqun/finetune/${MODEL_NAME}
-
-ZERO_STAGE=1
-export TORCH_EXTENSIONS_DIR=/cognitive_comp/dongxiaoqun/torch_extendsions
-config_json="./ds_config.${MODEL_NAME}.json"
-
-# Deepspeed figures out GAS dynamically from dynamic GBS via set_train_batch_size()
-cat < $config_json
-{
- "train_micro_batch_size_per_gpu": ${MICRO_BATCH_SIZE},
- "steps_per_print": 100,
- "gradient_clipping": 1.0,
- "zero_optimization": {
- "stage": $ZERO_STAGE,
- "contiguous_gradients": false,
- "overlap_comm": true,
- "reduce_scatter": true,
- "reduce_bucket_size": 50000000,
- "allgather_bucket_size": 500000000
- },
- "optimizer": {
- "type": "Adam",
- "params": {
- "lr": 1e-4,
- "betas": [
- 0.9,
- 0.95
- ],
- "eps": 1e-8,
- "weight_decay": 5e-2
- }
- },
- "scheduler": {
- "type": "WarmupLR",
- "params":{
- "warmup_min_lr": 5e-6,
- "warmup_max_lr": 1e-4
- }
- },
- "zero_allow_untested_optimizer": false,
- "fp16": {
- "enabled": true,
- "loss_scale": 0,
- "loss_scale_window": 1000,
- "hysteresis": 2,
- "min_loss_scale": 1
- },
- "activation_checkpointing": {
- "partition_activations": false,
- "contiguous_memory_optimization": false
- },
- "wall_clock_breakdown": false
-}
-EOT
-
-# export PL_DEEPSPEED_CONFIG_PATH=$config_json
-
-TRAINER_ARGS="
- --max_epochs 2 \
- --gpus 1 \
- --num_nodes 1 \
- --strategy deepspeed_stage_${ZERO_STAGE} \
- --default_root_dir $ROOT_DIR \
- --dirpath $ROOT_DIR/ckpt \
- --save_top_k 3 \
- --monitor val_loss \
- --mode min \
- --save_last \
- --every_n_train_steps 0 \
- --val_check_interval 0.1 \
-"
-
-prompt='"'
-DATA_ARGS="
- --datasets_name lcsts \
- --num_workers 8 \
- --train_batchsize $MICRO_BATCH_SIZE \
- --val_batchsize $MICRO_BATCH_SIZE \
- --test_batchsize $MICRO_BATCH_SIZE \
- --max_enc_length 128 \
- --max_dec_length 64 \
- --val_datasets_field val \
- --prompt $prompt \
-"
-
-MODEL_ARGS="
- --pretrained_model_path /cognitive_comp/gaoxinyu/pretrained_model/bart-base \
- --output_save_path $ROOT_DIR/${MODEL_NAME}_predict_lcsts.json \
- --learning_rate 1e-4 \
- --weight_decay 0.1 \
- --precision 16 \
-"
-
-SCRIPTS_PATH=seq2seq_summary.py
-
-export CMD=" \
- $SCRIPTS_PATH \
- $TRAINER_ARGS \
- $MODEL_ARGS \
- $DATA_ARGS \
- "
-
-echo $CMD
-
-#singularity exec --nv -B /cognitive_comp/ganruyi/Megatron/:/cognitive_comp/ganruyi/Megatron/,/cognitive_comp/gaoxinyu/:/cognitive_comp/gaoxinyu/ $SINGULARITY_PATH python $CMD
-
-# to debug - add echo (it exits and prints what it would have launched)
-#run_cmd="$PY_LAUNCHER $CMD"
-# srun --nodes=1 --gres=gpu:4 --ntasks-per-node=4 --cpus-per-gpu=20
-source activate
-conda activate torchnew
-srun --nodes=1 --ntasks-per-node=1 --gres=gpu:1 --cpus-per-task=30 -o ${MODEL_NAME}-%J.log --jobid=229623 bash -c 'python3 $SCRIPT_PATH $CMD'
diff --git a/spaces/fffiloni/Video-Matting-Anything/GroundingDINO/groundingdino/version.py b/spaces/fffiloni/Video-Matting-Anything/GroundingDINO/groundingdino/version.py
deleted file mode 100644
index b794fd409a5e3b3b65ad76a43d6a01a318877640..0000000000000000000000000000000000000000
--- a/spaces/fffiloni/Video-Matting-Anything/GroundingDINO/groundingdino/version.py
+++ /dev/null
@@ -1 +0,0 @@
-__version__ = '0.1.0'
diff --git a/spaces/fffiloni/controlnet-animation-doodle/node_modules/engine.io/node_modules/debug/src/browser.js b/spaces/fffiloni/controlnet-animation-doodle/node_modules/engine.io/node_modules/debug/src/browser.js
deleted file mode 100644
index cd0fc35d1ee11e0d6e15421021a54c18958e04d9..0000000000000000000000000000000000000000
--- a/spaces/fffiloni/controlnet-animation-doodle/node_modules/engine.io/node_modules/debug/src/browser.js
+++ /dev/null
@@ -1,269 +0,0 @@
-/* eslint-env browser */
-
-/**
- * This is the web browser implementation of `debug()`.
- */
-
-exports.formatArgs = formatArgs;
-exports.save = save;
-exports.load = load;
-exports.useColors = useColors;
-exports.storage = localstorage();
-exports.destroy = (() => {
- let warned = false;
-
- return () => {
- if (!warned) {
- warned = true;
- console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
- }
- };
-})();
-
-/**
- * Colors.
- */
-
-exports.colors = [
- '#0000CC',
- '#0000FF',
- '#0033CC',
- '#0033FF',
- '#0066CC',
- '#0066FF',
- '#0099CC',
- '#0099FF',
- '#00CC00',
- '#00CC33',
- '#00CC66',
- '#00CC99',
- '#00CCCC',
- '#00CCFF',
- '#3300CC',
- '#3300FF',
- '#3333CC',
- '#3333FF',
- '#3366CC',
- '#3366FF',
- '#3399CC',
- '#3399FF',
- '#33CC00',
- '#33CC33',
- '#33CC66',
- '#33CC99',
- '#33CCCC',
- '#33CCFF',
- '#6600CC',
- '#6600FF',
- '#6633CC',
- '#6633FF',
- '#66CC00',
- '#66CC33',
- '#9900CC',
- '#9900FF',
- '#9933CC',
- '#9933FF',
- '#99CC00',
- '#99CC33',
- '#CC0000',
- '#CC0033',
- '#CC0066',
- '#CC0099',
- '#CC00CC',
- '#CC00FF',
- '#CC3300',
- '#CC3333',
- '#CC3366',
- '#CC3399',
- '#CC33CC',
- '#CC33FF',
- '#CC6600',
- '#CC6633',
- '#CC9900',
- '#CC9933',
- '#CCCC00',
- '#CCCC33',
- '#FF0000',
- '#FF0033',
- '#FF0066',
- '#FF0099',
- '#FF00CC',
- '#FF00FF',
- '#FF3300',
- '#FF3333',
- '#FF3366',
- '#FF3399',
- '#FF33CC',
- '#FF33FF',
- '#FF6600',
- '#FF6633',
- '#FF9900',
- '#FF9933',
- '#FFCC00',
- '#FFCC33'
-];
-
-/**
- * Currently only WebKit-based Web Inspectors, Firefox >= v31,
- * and the Firebug extension (any Firefox version) are known
- * to support "%c" CSS customizations.
- *
- * TODO: add a `localStorage` variable to explicitly enable/disable colors
- */
-
-// eslint-disable-next-line complexity
-function useColors() {
- // NB: In an Electron preload script, document will be defined but not fully
- // initialized. Since we know we're in Chrome, we'll just detect this case
- // explicitly
- if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
- return true;
- }
-
- // Internet Explorer and Edge do not support colors.
- if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
- return false;
- }
-
- // Is webkit? http://stackoverflow.com/a/16459606/376773
- // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
- return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
- // Is firebug? http://stackoverflow.com/a/398120/376773
- (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
- // Is firefox >= v31?
- // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
- (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
- // Double check webkit in userAgent just in case we are in a worker
- (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
-}
-
-/**
- * Colorize log arguments if enabled.
- *
- * @api public
- */
-
-function formatArgs(args) {
- args[0] = (this.useColors ? '%c' : '') +
- this.namespace +
- (this.useColors ? ' %c' : ' ') +
- args[0] +
- (this.useColors ? '%c ' : ' ') +
- '+' + module.exports.humanize(this.diff);
-
- if (!this.useColors) {
- return;
- }
-
- const c = 'color: ' + this.color;
- args.splice(1, 0, c, 'color: inherit');
-
- // The final "%c" is somewhat tricky, because there could be other
- // arguments passed either before or after the %c, so we need to
- // figure out the correct index to insert the CSS into
- let index = 0;
- let lastC = 0;
- args[0].replace(/%[a-zA-Z%]/g, match => {
- if (match === '%%') {
- return;
- }
- index++;
- if (match === '%c') {
- // We only are interested in the *last* %c
- // (the user may have provided their own)
- lastC = index;
- }
- });
-
- args.splice(lastC, 0, c);
-}
-
-/**
- * Invokes `console.debug()` when available.
- * No-op when `console.debug` is not a "function".
- * If `console.debug` is not available, falls back
- * to `console.log`.
- *
- * @api public
- */
-exports.log = console.debug || console.log || (() => {});
-
-/**
- * Save `namespaces`.
- *
- * @param {String} namespaces
- * @api private
- */
-function save(namespaces) {
- try {
- if (namespaces) {
- exports.storage.setItem('debug', namespaces);
- } else {
- exports.storage.removeItem('debug');
- }
- } catch (error) {
- // Swallow
- // XXX (@Qix-) should we be logging these?
- }
-}
-
-/**
- * Load `namespaces`.
- *
- * @return {String} returns the previously persisted debug modes
- * @api private
- */
-function load() {
- let r;
- try {
- r = exports.storage.getItem('debug');
- } catch (error) {
- // Swallow
- // XXX (@Qix-) should we be logging these?
- }
-
- // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
- if (!r && typeof process !== 'undefined' && 'env' in process) {
- r = process.env.DEBUG;
- }
-
- return r;
-}
-
-/**
- * Localstorage attempts to return the localstorage.
- *
- * This is necessary because safari throws
- * when a user disables cookies/localstorage
- * and you attempt to access it.
- *
- * @return {LocalStorage}
- * @api private
- */
-
-function localstorage() {
- try {
- // TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
- // The Browser also has localStorage in the global context.
- return localStorage;
- } catch (error) {
- // Swallow
- // XXX (@Qix-) should we be logging these?
- }
-}
-
-module.exports = require('./common')(exports);
-
-const {formatters} = module.exports;
-
-/**
- * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
- */
-
-formatters.j = function (v) {
- try {
- return JSON.stringify(v);
- } catch (error) {
- return '[UnexpectedJSONParseError]: ' + error.message;
- }
-};
diff --git a/spaces/fgenie/scamtext_PAL_self_consistency/funcs/f_57.py b/spaces/fgenie/scamtext_PAL_self_consistency/funcs/f_57.py
deleted file mode 100644
index 748e23c9f64b6870010258e37bd8d8380aeefdf5..0000000000000000000000000000000000000000
--- a/spaces/fgenie/scamtext_PAL_self_consistency/funcs/f_57.py
+++ /dev/null
@@ -1,17 +0,0 @@
-def is_spam(message: str) -> bool:
- import re
-
- # Patterns for detecting spam
- patterns = [
- r"(?i)\b(추천|상승|단기간|익절|무료교육|달성|거래량|폭등)\b", # 유형 1,2,4에서 발견됩니다.
- r"(?i)\b(http|bit\.ly|t\.ly|me2\.kr|dokdo\.in|buly\.kr)\b", # 유형 1,2,3,4,5에서 발견됩니다.
- r"(?i)\b(입금|출금)\b", # 일부 스팸 메시지에서 발견됩니다.
- r"(%|상한가|모션|목표)\b", # 일부 스팸 메시지에서 발견됩니다.
- r"(?i)\b(광고)\b", # 스팸 메시지에서 때때로 발견됩니다.
- ]
-
- for pattern in patterns:
- if re.search(pattern, message):
- return True
-
- return False
\ No newline at end of file
diff --git a/spaces/fhipol/deeplearning/detector.py b/spaces/fhipol/deeplearning/detector.py
deleted file mode 100644
index 492616bf5dc808d6db8398b42a8db43f1790ae0e..0000000000000000000000000000000000000000
--- a/spaces/fhipol/deeplearning/detector.py
+++ /dev/null
@@ -1,54 +0,0 @@
-import os
-import torch
-from PIL import Image
-
-from detector_model import ModelExecutor, HumanModelExecutor, BrandsModelExecutor
-
-
-class ObjectDetector:
-
- def __init__(self, model_executor: ModelExecutor):
-
- # threshold used for recall/false negatives
- self.threshold = 0.5
- self.device = torch.device("cpu")
- self.model_executor = model_executor
-
- def detect_object(self, img_path):
-
- img = Image.open(img_path)
- img_data = self.model_executor.transform(img).unsqueeze(0)
- img_data = img_data.to(self.device)
-
- output = self.model_executor.model(img_data)
- prob_output = torch.softmax(output, dim=1)
- prob, pred = torch.max(prob_output, 1)
-
- return prob.item(), pred.item()
-
- def detect_all_object_in_dir(self, test_path):
-
- imgs_paths = os.listdir(test_path)
-
- for rel_img_path in imgs_paths:
-
- img_path = test_path + f"/{rel_img_path}"
- prob, pred = self.detect_object(img_path)
-
- print(f"{self.model_executor.name} detector in {rel_img_path}: predicted category {pred} with p {prob}")
-
- # Print the results
- if pred == 1 and prob > self.threshold:
- print("Object detected")
- else:
- print("No object detected")
-
-
-if __name__ == "__main__":
- test_path = os.getcwd() + "/test_imgs"
-
- model_humans = HumanModelExecutor(train_model=False, force_cpu=True)
- model_logos = BrandsModelExecutor(train_model=False, force_cpu=True)
-
- ObjectDetector(model_humans).detect_all_object_in_dir(test_path)
- ObjectDetector(model_logos).detect_all_object_in_dir(test_path)
diff --git a/spaces/fiyen/YangyangChatGPT/custom.css b/spaces/fiyen/YangyangChatGPT/custom.css
deleted file mode 100644
index 5143eb138ea2469d8c457c71cb210fd3fb7cbe15..0000000000000000000000000000000000000000
--- a/spaces/fiyen/YangyangChatGPT/custom.css
+++ /dev/null
@@ -1,162 +0,0 @@
-:root {
- --chatbot-color-light: #F3F3F3;
- --chatbot-color-dark: #121111;
-}
-
-/* status_display */
-#status_display {
- display: flex;
- min-height: 2.5em;
- align-items: flex-end;
- justify-content: flex-end;
-}
-#status_display p {
- font-size: .85em;
- font-family: monospace;
- color: var(--body-text-color-subdued);
-}
-
-#chuanhu_chatbot, #status_display {
- transition: all 0.6s;
-}
-/* list */
-ol:not(.options), ul:not(.options) {
- padding-inline-start: 2em !important;
-}
-
-/* 亮色 */
-#chuanhu_chatbot {
- background-color: var(--chatbot-color-light) !important;
-}
-[data-testid = "bot"] {
- background-color: #FFFFFF !important;
-}
-[data-testid = "user"] {
- background-color: #95EC69 !important;
-}
-/* 对话气泡 */
-[class *= "message"] {
- border-radius: var(--radius-xl) !important;
- border: none;
- padding: var(--spacing-xl) !important;
- font-size: var(--text-md) !important;
- line-height: var(--line-md) !important;
- min-height: calc(var(--text-md)*var(--line-md) + 2*var(--spacing-xl));
- min-width: calc(var(--text-md)*var(--line-md) + 2*var(--spacing-xl));
-}
-[data-testid = "bot"] {
- max-width: 85%;
- border-bottom-left-radius: 0 !important;
-}
-[data-testid = "user"] {
- max-width: 85%;
- width: auto !important;
- border-bottom-right-radius: 0 !important;
-}
-/* 表格 */
-table {
- margin: 1em 0;
- border-collapse: collapse;
- empty-cells: show;
-}
-td,th {
- border: 1.2px solid var(--border-color-primary) !important;
- padding: 0.2em;
-}
-thead {
- background-color: rgba(175,184,193,0.2);
-}
-thead th {
- padding: .5em .2em;
-}
-/* 行内代码 */
-code {
- display: inline;
- white-space: break-spaces;
- border-radius: 6px;
- margin: 0 2px 0 2px;
- padding: .2em .4em .1em .4em;
- background-color: rgba(175,184,193,0.2);
-}
-/* 代码块 */
-pre code {
- display: block;
- overflow: auto;
- white-space: pre;
- background-color: hsla(0, 0%, 0%, 80%)!important;
- border-radius: 10px;
- padding: 1.4em 1.2em 0em 1.4em;
- margin: 1.2em 2em 1.2em 0.5em;
- color: #FFF;
- box-shadow: 6px 6px 16px hsla(0, 0%, 0%, 0.2);
-}
-/* 代码高亮样式 */
-.highlight .hll { background-color: #49483e }
-.highlight .c { color: #75715e } /* Comment */
-.highlight .err { color: #960050; background-color: #1e0010 } /* Error */
-.highlight .k { color: #66d9ef } /* Keyword */
-.highlight .l { color: #ae81ff } /* Literal */
-.highlight .n { color: #f8f8f2 } /* Name */
-.highlight .o { color: #f92672 } /* Operator */
-.highlight .p { color: #f8f8f2 } /* Punctuation */
-.highlight .ch { color: #75715e } /* Comment.Hashbang */
-.highlight .cm { color: #75715e } /* Comment.Multiline */
-.highlight .cp { color: #75715e } /* Comment.Preproc */
-.highlight .cpf { color: #75715e } /* Comment.PreprocFile */
-.highlight .c1 { color: #75715e } /* Comment.Single */
-.highlight .cs { color: #75715e } /* Comment.Special */
-.highlight .gd { color: #f92672 } /* Generic.Deleted */
-.highlight .ge { font-style: italic } /* Generic.Emph */
-.highlight .gi { color: #a6e22e } /* Generic.Inserted */
-.highlight .gs { font-weight: bold } /* Generic.Strong */
-.highlight .gu { color: #75715e } /* Generic.Subheading */
-.highlight .kc { color: #66d9ef } /* Keyword.Constant */
-.highlight .kd { color: #66d9ef } /* Keyword.Declaration */
-.highlight .kn { color: #f92672 } /* Keyword.Namespace */
-.highlight .kp { color: #66d9ef } /* Keyword.Pseudo */
-.highlight .kr { color: #66d9ef } /* Keyword.Reserved */
-.highlight .kt { color: #66d9ef } /* Keyword.Type */
-.highlight .ld { color: #e6db74 } /* Literal.Date */
-.highlight .m { color: #ae81ff } /* Literal.Number */
-.highlight .s { color: #e6db74 } /* Literal.String */
-.highlight .na { color: #a6e22e } /* Name.Attribute */
-.highlight .nb { color: #f8f8f2 } /* Name.Builtin */
-.highlight .nc { color: #a6e22e } /* Name.Class */
-.highlight .no { color: #66d9ef } /* Name.Constant */
-.highlight .nd { color: #a6e22e } /* Name.Decorator */
-.highlight .ni { color: #f8f8f2 } /* Name.Entity */
-.highlight .ne { color: #a6e22e } /* Name.Exception */
-.highlight .nf { color: #a6e22e } /* Name.Function */
-.highlight .nl { color: #f8f8f2 } /* Name.Label */
-.highlight .nn { color: #f8f8f2 } /* Name.Namespace */
-.highlight .nx { color: #a6e22e } /* Name.Other */
-.highlight .py { color: #f8f8f2 } /* Name.Property */
-.highlight .nt { color: #f92672 } /* Name.Tag */
-.highlight .nv { color: #f8f8f2 } /* Name.Variable */
-.highlight .ow { color: #f92672 } /* Operator.Word */
-.highlight .w { color: #f8f8f2 } /* Text.Whitespace */
-.highlight .mb { color: #ae81ff } /* Literal.Number.Bin */
-.highlight .mf { color: #ae81ff } /* Literal.Number.Float */
-.highlight .mh { color: #ae81ff } /* Literal.Number.Hex */
-.highlight .mi { color: #ae81ff } /* Literal.Number.Integer */
-.highlight .mo { color: #ae81ff } /* Literal.Number.Oct */
-.highlight .sa { color: #e6db74 } /* Literal.String.Affix */
-.highlight .sb { color: #e6db74 } /* Literal.String.Backtick */
-.highlight .sc { color: #e6db74 } /* Literal.String.Char */
-.highlight .dl { color: #e6db74 } /* Literal.String.Delimiter */
-.highlight .sd { color: #e6db74 } /* Literal.String.Doc */
-.highlight .s2 { color: #e6db74 } /* Literal.String.Double */
-.highlight .se { color: #ae81ff } /* Literal.String.Escape */
-.highlight .sh { color: #e6db74 } /* Literal.String.Heredoc */
-.highlight .si { color: #e6db74 } /* Literal.String.Interpol */
-.highlight .sx { color: #e6db74 } /* Literal.String.Other */
-.highlight .sr { color: #e6db74 } /* Literal.String.Regex */
-.highlight .s1 { color: #e6db74 } /* Literal.String.Single */
-.highlight .ss { color: #e6db74 } /* Literal.String.Symbol */
-.highlight .bp { color: #f8f8f2 } /* Name.Builtin.Pseudo */
-.highlight .fm { color: #a6e22e } /* Name.Function.Magic */
-.highlight .vc { color: #f8f8f2 } /* Name.Variable.Class */
-.highlight .vg { color: #f8f8f2 } /* Name.Variable.Global */
-.highlight .vi { color: #f8f8f2 } /* Name.Variable.Instance */
-.highlight .vm { color: #f8f8f2 } /* Name.Variable.Magic */
-.highlight .il { color: #ae81ff } /* Literal.Number.Integer.Long */
diff --git a/spaces/floriankrempl/mtg_rules_bot/mtg/bot/chat_history.py b/spaces/floriankrempl/mtg_rules_bot/mtg/bot/chat_history.py
deleted file mode 100644
index c067512d9693509dc0d87fd666f96272c88081ed..0000000000000000000000000000000000000000
--- a/spaces/floriankrempl/mtg_rules_bot/mtg/bot/chat_history.py
+++ /dev/null
@@ -1,49 +0,0 @@
-from dataclasses import dataclass, field
-
-from mtg.objects import Message
-
-
-@dataclass
-class ChatHistory:
- chat: list[Message] = field(default_factory=list)
-
- def add_message(self, message: Message):
- self.chat.append(message)
-
- def clear(self):
- self.chat = []
-
- def get_card_data(self, number_of_messages=2, max_number_of_cards=4):
- """Get Card data from last n messages in text form."""
- card_data = ""
- cards = []
- for message in self.chat[-number_of_messages:]:
- cards.extend(message.cards)
-
- card_data += "\n".join(
- [card.to_text() for card in cards[-max_number_of_cards:]]
- )
- if card_data == "":
- card_data = "No Card Data."
- return card_data
-
- def get_human_readable_chat(self, number_of_messages=4) -> list[list[str, str]]:
- """Create Chat for display in gradio bot.
-
- Chat has to be in format list of lists. First message in the list is user second is bot.
- Example:
- chat = [[user, bot], [user, bot]]
- """
- chat = []
- for message in self.chat[-number_of_messages:]:
- if message.role == "user":
- chat.append([message.processed_text])
- if message.role == "assistant":
- if not chat:
- chat.append([None, message.processed_text])
- else:
- chat[-1].append(message.processed_text)
-
- if len(chat[-1]) == 1:
- chat[-1].append(None)
- return chat
diff --git a/spaces/flowers-team/SocialAISchool/gym-minigrid/gym_minigrid/social_ai_envs/case_studies_envs/applestealingcasestudiesenvs.py b/spaces/flowers-team/SocialAISchool/gym-minigrid/gym_minigrid/social_ai_envs/case_studies_envs/applestealingcasestudiesenvs.py
deleted file mode 100644
index f03e6052301ca5322a766e04c3c5cf093e773c44..0000000000000000000000000000000000000000
--- a/spaces/flowers-team/SocialAISchool/gym-minigrid/gym_minigrid/social_ai_envs/case_studies_envs/applestealingcasestudiesenvs.py
+++ /dev/null
@@ -1,87 +0,0 @@
-from gym_minigrid.social_ai_envs.socialaiparamenv import SocialAIParamEnv
-from gym_minigrid.parametric_env import *
-from gym_minigrid.register import register
-
-import inspect, importlib
-
-# for used for automatic registration of environments
-defined_classes = [name for name, _ in inspect.getmembers(importlib.import_module(__name__), inspect.isclass)]
-
-class AppleStealingParamEnv(SocialAIParamEnv):
-
- def __init__(self, obstacles, asocial, walk, **kwargs):
-
- self.asocial = asocial
- self.obstacles = obstacles
- self.walk = walk
-
- super(AppleStealingParamEnv, self).__init__(**kwargs)
-
- def construct_tree(self):
- tree = ParameterTree()
-
- env_type_nd = tree.add_node("Env_type", type="param")
-
- # Collaboration
- collab_nd = tree.add_node("AppleStealing", parent=env_type_nd, type="value")
-
- # colab_type_nd = tree.add_node("Problem", parent=collab_nd, type="param")
- # tree.add_node("AppleStealing", parent=colab_type_nd, type="value")
- role_nd = tree.add_node("Version", parent=collab_nd, type="param")
- if self.asocial:
- tree.add_node("Asocial", parent=role_nd, type="value")
- else:
- social_nd = tree.add_node("Social", parent=role_nd, type="value")
-
- role_nd = tree.add_node("NPC_movement", parent=social_nd, type="param")
- if self.walk:
- tree.add_node("Walking", parent=role_nd, type="value")
- else:
- tree.add_node("Rotating", parent=role_nd, type="value")
-
- obstacles_nd = tree.add_node("Obstacles", parent=collab_nd, type="param")
-
- if self.obstacles not in ["No", "A_bit", "Medium", "A_lot"]:
- raise ValueError("Undefined obstacle amount.")
-
- tree.add_node(self.obstacles, parent=obstacles_nd, type="value")
-
- return tree
-
-
-# automatic registration of environments
-defined_classes_ = [name for name, _ in inspect.getmembers(importlib.import_module(__name__), inspect.isclass)]
-
-envs = list(set(defined_classes_) - set(defined_classes))
-assert all([e.endswith("Env") for e in envs])
-
-
-# register testing envs : cues x problems x {social, asocial} x {joint attention, no}
-for asocial in [True, False]:
- for obst in ["No", "A_bit", "Medium", "A_lot"]:
- if asocial:
- env_name = f'{"Asocial" if asocial else ""}AppleStealingObst_{obst}ParamEnv'
-
- register(
- id='SocialAI-{}-v1'.format(env_name),
- entry_point='gym_minigrid.social_ai_envs:AppleStealingParamEnv',
- kwargs={
- 'asocial': asocial,
- 'obstacles': obst,
- 'walk': False,
- }
- )
-
- else:
- for walk in [True, False]:
- env_name = f'{"Asocial" if asocial else ""}AppleStealing{"Walk" if walk and not asocial else ""}Obst_{obst}ParamEnv'
-
- register(
- id='SocialAI-{}-v1'.format(env_name),
- entry_point='gym_minigrid.social_ai_envs:AppleStealingParamEnv',
- kwargs={
- 'asocial': asocial,
- 'obstacles': obst,
- 'walk': walk,
- }
- )
diff --git a/spaces/freddiezhang/honor/README.md b/spaces/freddiezhang/honor/README.md
deleted file mode 100644
index 898c52b3c535e4d6dee245f31af513adbf225691..0000000000000000000000000000000000000000
--- a/spaces/freddiezhang/honor/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: HonOR
-emoji: 🏆
-colorFrom: green
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.14.0
-app_file: app.py
-pinned: true
-models: ['freddiezhang/honor']
-datasets: ['freddiezhang/honordata']
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/configs/_base_/datasets/pascal_voc12.py b/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/configs/_base_/datasets/pascal_voc12.py
deleted file mode 100644
index ba1d42d0c5781f56dc177d860d856bb34adce555..0000000000000000000000000000000000000000
--- a/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/configs/_base_/datasets/pascal_voc12.py
+++ /dev/null
@@ -1,57 +0,0 @@
-# dataset settings
-dataset_type = 'PascalVOCDataset'
-data_root = 'data/VOCdevkit/VOC2012'
-img_norm_cfg = dict(
- mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
-crop_size = (512, 512)
-train_pipeline = [
- dict(type='LoadImageFromFile'),
- dict(type='LoadAnnotations'),
- dict(type='Resize', img_scale=(2048, 512), ratio_range=(0.5, 2.0)),
- dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
- dict(type='RandomFlip', prob=0.5),
- dict(type='PhotoMetricDistortion'),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
- dict(type='DefaultFormatBundle'),
- dict(type='Collect', keys=['img', 'gt_semantic_seg']),
-]
-test_pipeline = [
- dict(type='LoadImageFromFile'),
- dict(
- type='MultiScaleFlipAug',
- img_scale=(2048, 512),
- # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
- flip=False,
- transforms=[
- dict(type='Resize', keep_ratio=True),
- dict(type='RandomFlip'),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='ImageToTensor', keys=['img']),
- dict(type='Collect', keys=['img']),
- ])
-]
-data = dict(
- samples_per_gpu=4,
- workers_per_gpu=4,
- train=dict(
- type=dataset_type,
- data_root=data_root,
- img_dir='JPEGImages',
- ann_dir='SegmentationClass',
- split='ImageSets/Segmentation/train.txt',
- pipeline=train_pipeline),
- val=dict(
- type=dataset_type,
- data_root=data_root,
- img_dir='JPEGImages',
- ann_dir='SegmentationClass',
- split='ImageSets/Segmentation/val.txt',
- pipeline=test_pipeline),
- test=dict(
- type=dataset_type,
- data_root=data_root,
- img_dir='JPEGImages',
- ann_dir='SegmentationClass',
- split='ImageSets/Segmentation/val.txt',
- pipeline=test_pipeline))
diff --git a/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/configs/_base_/models/fpn_r50.py b/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/configs/_base_/models/fpn_r50.py
deleted file mode 100644
index 86ab327db92e44c14822d65f1c9277cb007f17c1..0000000000000000000000000000000000000000
--- a/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/configs/_base_/models/fpn_r50.py
+++ /dev/null
@@ -1,36 +0,0 @@
-# model settings
-norm_cfg = dict(type='SyncBN', requires_grad=True)
-model = dict(
- type='EncoderDecoder',
- pretrained='open-mmlab://resnet50_v1c',
- backbone=dict(
- type='ResNetV1c',
- depth=50,
- num_stages=4,
- out_indices=(0, 1, 2, 3),
- dilations=(1, 1, 1, 1),
- strides=(1, 2, 2, 2),
- norm_cfg=norm_cfg,
- norm_eval=False,
- style='pytorch',
- contract_dilation=True),
- neck=dict(
- type='FPN',
- in_channels=[256, 512, 1024, 2048],
- out_channels=256,
- num_outs=4),
- decode_head=dict(
- type='FPNHead',
- in_channels=[256, 256, 256, 256],
- in_index=[0, 1, 2, 3],
- feature_strides=[4, 8, 16, 32],
- channels=128,
- dropout_ratio=0.1,
- num_classes=19,
- norm_cfg=norm_cfg,
- align_corners=False,
- loss_decode=dict(
- type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
- # model training and testing settings
- train_cfg=dict(),
- test_cfg=dict(mode='whole'))
diff --git a/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/mmseg/models/decode_heads/ann_head.py b/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/mmseg/models/decode_heads/ann_head.py
deleted file mode 100644
index 30aaacc2cafc568d3de71d1477b4de0dc0fea9d3..0000000000000000000000000000000000000000
--- a/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/mmseg/models/decode_heads/ann_head.py
+++ /dev/null
@@ -1,245 +0,0 @@
-import torch
-import torch.nn as nn
-from annotator.uniformer.mmcv.cnn import ConvModule
-
-from ..builder import HEADS
-from ..utils import SelfAttentionBlock as _SelfAttentionBlock
-from .decode_head import BaseDecodeHead
-
-
-class PPMConcat(nn.ModuleList):
- """Pyramid Pooling Module that only concat the features of each layer.
-
- Args:
- pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid
- Module.
- """
-
- def __init__(self, pool_scales=(1, 3, 6, 8)):
- super(PPMConcat, self).__init__(
- [nn.AdaptiveAvgPool2d(pool_scale) for pool_scale in pool_scales])
-
- def forward(self, feats):
- """Forward function."""
- ppm_outs = []
- for ppm in self:
- ppm_out = ppm(feats)
- ppm_outs.append(ppm_out.view(*feats.shape[:2], -1))
- concat_outs = torch.cat(ppm_outs, dim=2)
- return concat_outs
-
-
-class SelfAttentionBlock(_SelfAttentionBlock):
- """Make a ANN used SelfAttentionBlock.
-
- Args:
- low_in_channels (int): Input channels of lower level feature,
- which is the key feature for self-attention.
- high_in_channels (int): Input channels of higher level feature,
- which is the query feature for self-attention.
- channels (int): Output channels of key/query transform.
- out_channels (int): Output channels.
- share_key_query (bool): Whether share projection weight between key
- and query projection.
- query_scale (int): The scale of query feature map.
- key_pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid
- Module of key feature.
- conv_cfg (dict|None): Config of conv layers.
- norm_cfg (dict|None): Config of norm layers.
- act_cfg (dict|None): Config of activation layers.
- """
-
- def __init__(self, low_in_channels, high_in_channels, channels,
- out_channels, share_key_query, query_scale, key_pool_scales,
- conv_cfg, norm_cfg, act_cfg):
- key_psp = PPMConcat(key_pool_scales)
- if query_scale > 1:
- query_downsample = nn.MaxPool2d(kernel_size=query_scale)
- else:
- query_downsample = None
- super(SelfAttentionBlock, self).__init__(
- key_in_channels=low_in_channels,
- query_in_channels=high_in_channels,
- channels=channels,
- out_channels=out_channels,
- share_key_query=share_key_query,
- query_downsample=query_downsample,
- key_downsample=key_psp,
- key_query_num_convs=1,
- key_query_norm=True,
- value_out_num_convs=1,
- value_out_norm=False,
- matmul_norm=True,
- with_out=True,
- conv_cfg=conv_cfg,
- norm_cfg=norm_cfg,
- act_cfg=act_cfg)
-
-
-class AFNB(nn.Module):
- """Asymmetric Fusion Non-local Block(AFNB)
-
- Args:
- low_in_channels (int): Input channels of lower level feature,
- which is the key feature for self-attention.
- high_in_channels (int): Input channels of higher level feature,
- which is the query feature for self-attention.
- channels (int): Output channels of key/query transform.
- out_channels (int): Output channels.
- and query projection.
- query_scales (tuple[int]): The scales of query feature map.
- Default: (1,)
- key_pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid
- Module of key feature.
- conv_cfg (dict|None): Config of conv layers.
- norm_cfg (dict|None): Config of norm layers.
- act_cfg (dict|None): Config of activation layers.
- """
-
- def __init__(self, low_in_channels, high_in_channels, channels,
- out_channels, query_scales, key_pool_scales, conv_cfg,
- norm_cfg, act_cfg):
- super(AFNB, self).__init__()
- self.stages = nn.ModuleList()
- for query_scale in query_scales:
- self.stages.append(
- SelfAttentionBlock(
- low_in_channels=low_in_channels,
- high_in_channels=high_in_channels,
- channels=channels,
- out_channels=out_channels,
- share_key_query=False,
- query_scale=query_scale,
- key_pool_scales=key_pool_scales,
- conv_cfg=conv_cfg,
- norm_cfg=norm_cfg,
- act_cfg=act_cfg))
- self.bottleneck = ConvModule(
- out_channels + high_in_channels,
- out_channels,
- 1,
- conv_cfg=conv_cfg,
- norm_cfg=norm_cfg,
- act_cfg=None)
-
- def forward(self, low_feats, high_feats):
- """Forward function."""
- priors = [stage(high_feats, low_feats) for stage in self.stages]
- context = torch.stack(priors, dim=0).sum(dim=0)
- output = self.bottleneck(torch.cat([context, high_feats], 1))
- return output
-
-
-class APNB(nn.Module):
- """Asymmetric Pyramid Non-local Block (APNB)
-
- Args:
- in_channels (int): Input channels of key/query feature,
- which is the key feature for self-attention.
- channels (int): Output channels of key/query transform.
- out_channels (int): Output channels.
- query_scales (tuple[int]): The scales of query feature map.
- Default: (1,)
- key_pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid
- Module of key feature.
- conv_cfg (dict|None): Config of conv layers.
- norm_cfg (dict|None): Config of norm layers.
- act_cfg (dict|None): Config of activation layers.
- """
-
- def __init__(self, in_channels, channels, out_channels, query_scales,
- key_pool_scales, conv_cfg, norm_cfg, act_cfg):
- super(APNB, self).__init__()
- self.stages = nn.ModuleList()
- for query_scale in query_scales:
- self.stages.append(
- SelfAttentionBlock(
- low_in_channels=in_channels,
- high_in_channels=in_channels,
- channels=channels,
- out_channels=out_channels,
- share_key_query=True,
- query_scale=query_scale,
- key_pool_scales=key_pool_scales,
- conv_cfg=conv_cfg,
- norm_cfg=norm_cfg,
- act_cfg=act_cfg))
- self.bottleneck = ConvModule(
- 2 * in_channels,
- out_channels,
- 1,
- conv_cfg=conv_cfg,
- norm_cfg=norm_cfg,
- act_cfg=act_cfg)
-
- def forward(self, feats):
- """Forward function."""
- priors = [stage(feats, feats) for stage in self.stages]
- context = torch.stack(priors, dim=0).sum(dim=0)
- output = self.bottleneck(torch.cat([context, feats], 1))
- return output
-
-
-@HEADS.register_module()
-class ANNHead(BaseDecodeHead):
- """Asymmetric Non-local Neural Networks for Semantic Segmentation.
-
- This head is the implementation of `ANNNet
- `_.
-
- Args:
- project_channels (int): Projection channels for Nonlocal.
- query_scales (tuple[int]): The scales of query feature map.
- Default: (1,)
- key_pool_scales (tuple[int]): The pooling scales of key feature map.
- Default: (1, 3, 6, 8).
- """
-
- def __init__(self,
- project_channels,
- query_scales=(1, ),
- key_pool_scales=(1, 3, 6, 8),
- **kwargs):
- super(ANNHead, self).__init__(
- input_transform='multiple_select', **kwargs)
- assert len(self.in_channels) == 2
- low_in_channels, high_in_channels = self.in_channels
- self.project_channels = project_channels
- self.fusion = AFNB(
- low_in_channels=low_in_channels,
- high_in_channels=high_in_channels,
- out_channels=high_in_channels,
- channels=project_channels,
- query_scales=query_scales,
- key_pool_scales=key_pool_scales,
- conv_cfg=self.conv_cfg,
- norm_cfg=self.norm_cfg,
- act_cfg=self.act_cfg)
- self.bottleneck = ConvModule(
- high_in_channels,
- self.channels,
- 3,
- padding=1,
- conv_cfg=self.conv_cfg,
- norm_cfg=self.norm_cfg,
- act_cfg=self.act_cfg)
- self.context = APNB(
- in_channels=self.channels,
- out_channels=self.channels,
- channels=project_channels,
- query_scales=query_scales,
- key_pool_scales=key_pool_scales,
- conv_cfg=self.conv_cfg,
- norm_cfg=self.norm_cfg,
- act_cfg=self.act_cfg)
-
- def forward(self, inputs):
- """Forward function."""
- low_feats, high_feats = self._transform_inputs(inputs)
- output = self.fusion(low_feats, high_feats)
- output = self.dropout(output)
- output = self.bottleneck(output)
- output = self.context(output)
- output = self.cls_seg(output)
-
- return output
diff --git a/spaces/gforguru/EmailGenerator/README.md b/spaces/gforguru/EmailGenerator/README.md
deleted file mode 100644
index 273f270f09c4d7a541d0a72283e6a9ab641d9441..0000000000000000000000000000000000000000
--- a/spaces/gforguru/EmailGenerator/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: EmailGenerator
-emoji: 🏆
-colorFrom: purple
-colorTo: yellow
-sdk: streamlit
-sdk_version: 1.26.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/gotiQspiryo/whisper-ui/examples/Extreme Landings Windows Crack [REPACK] Key.md b/spaces/gotiQspiryo/whisper-ui/examples/Extreme Landings Windows Crack [REPACK] Key.md
deleted file mode 100644
index e68463d67307670253c0a505e98387444f80823f..0000000000000000000000000000000000000000
--- a/spaces/gotiQspiryo/whisper-ui/examples/Extreme Landings Windows Crack [REPACK] Key.md
+++ /dev/null
@@ -1,93 +0,0 @@
-
-How to Download and Play Extreme Landings Windows Crack Key
-If you are a fan of flight simulation games, you might have heard of Extreme Landings Pro, a realistic and challenging game that lets you test your skills as a pilot in various scenarios. However, if you want to play this game on your Windows 10 PC, you might encounter some difficulties. The game is not officially available for Windows 10, and the only way to get it is to use a crack key that bypasses the security measures of the game.
-Extreme Landings Windows Crack Key
Download Zip ★★★★★ https://urlgoal.com/2uyM6n
-In this article, we will show you how to download and play Extreme Landings Windows Crack Key on your PC, using some simple steps and tools. We will also explain the risks and benefits of using a crack key, and some alternatives that you can try if you don't want to use one.
-What is Extreme Landings Windows Crack Key?
-Extreme Landings Windows Crack Key is a modified version of the original game that allows you to play it on your Windows 10 PC without paying for it or having a license. A crack key is a code that unlocks the features and functions of the game that are normally restricted or encrypted. By using a crack key, you can bypass the verification process of the game and enjoy it for free.
-However, using a crack key also comes with some risks and drawbacks. First of all, it is illegal and unethical to use a crack key, as it violates the terms and conditions of the game developer and publisher. You might face legal consequences or penalties if you are caught using a crack key. Secondly, using a crack key might expose your PC to malware or viruses that can harm your system or steal your data. Thirdly, using a crack key might compromise the quality and performance of the game, as it might not be compatible with your PC specifications or updates. You might experience bugs, glitches, crashes, or errors while playing the game.
-How to Download and Play Extreme Landings Windows Crack Key?
-If you still want to download and play Extreme Landings Windows Crack Key on your PC, you will need to follow these steps:
-
-- Download an Android emulator on your PC, such as BlueStacks or NoxPlayer. An Android emulator is a software that allows you to run Android apps and games on your PC.
-- Install and launch the Android emulator on your PC.
-- Download Extreme Landings Pro APK + MOD (All Unlocked) from a reliable source on the internet. This is a modified version of the game that has all the content unlocked and does not require a license.
-- Drag and drop the APK file into the Android emulator window, or use the built-in browser to locate and install it.
-- Once the installation is complete, launch Extreme Landings Pro from the emulator home screen.
-- Enjoy playing Extreme Landings Windows Crack Key on your PC.
-
-What are some alternatives to Extreme Landings Windows Crack Key?
-If you don't want to use a crack key to play Extreme Landings Pro on your PC, you can try some alternatives that are similar or better than this game. Here are some suggestions:
-
-- Microsoft Flight Simulator: This is one of the most realistic and immersive flight simulation games ever made. It features stunning graphics, dynamic weather, realistic physics, and over 37,000 airports around the world. You can fly any type of aircraft, from light planes to commercial jets, and explore the world in amazing detail. You can also customize your flight plan, weather conditions, time of day, and difficulty level. Microsoft Flight Simulator is available for Windows 10 and Xbox Series X/S.
-- X-Plane 11: This is another realistic and comprehensive flight simulation game that offers a wide range of aircraft, scenery, airports, and features. You can fly anything from gliders to helicopters to space shuttles, and experience realistic flight dynamics, weather effects, sound effects, and lighting effects. You can also create your own aircraft, scenery, airports, and missions with the powerful editing tools. X-Plane 11 is available for Windows 10, Mac OS X, and Linux.
-- Aerofly FS 2020: This is a mobile flight simulation game that delivers high-quality graphics, smooth performance, and easy controls. You can choose from over 200 airports and 21 aircraft models, ranging from single-engine planes to airliners. You can also enjoy realistic cockpit views, instrument displays, navigation systems, weather conditions, and physics. Aerofly FS 2020 is available for Android and iOS devices.
-
-Conclusion
-In conclusion, Extreme Landings Windows Crack Key is a way to play Extreme Landings Pro on your Windows 10 PC for free by using a modified version of the game that bypasses the security measures. However, using a crack key is illegal, unethical,
-risky,
-and potentially harmful for your PC
-and
-the game quality
-and performance.
-If you want to enjoy
-a
-flight simulation game on your PC,
-you should consider
-some alternatives
-that are
-similar or better than Extreme Landings Pro,
-such as Microsoft Flight Simulator,
-X-Plane 11,
-or Aerofly FS 2020.
-These games are
-officially available for
-Windows 10
-or other platforms,
-and offer
-a more realistic,
-immersive,
-and satisfying
-flight simulation experience.
-
-Why Should You Play Extreme Landings Windows Crack Key?
-Extreme Landings Windows Crack Key is not just a game, but a learning experience. You can improve your knowledge and skills in aviation, navigation, and emergency management. You can face realistic scenarios that challenge your decision-making, problem-solving, and reaction abilities. You can also enjoy the thrill and excitement of flying different types of aircraft in various weather conditions and locations.
-Extreme Landings Windows Crack Key is not just a simulation, but a masterpiece. You can appreciate the stunning graphics, smooth animations, and realistic sound effects that create an immersive atmosphere. You can also explore the detailed and accurate maps, airports, and runways that are based on real-world data. You can also customize your aircraft, flight plan, and difficulty level to suit your preferences and goals.
-How to Get Extreme Landings Windows Crack Key for Free?
-Extreme Landings Windows Crack Key is not just a crack key, but a gift. You can get it for free without paying for the original game or having a license. You can also avoid the verification process of the game and enjoy all the features and functions that are normally restricted or encrypted. You can also access all the content that is unlocked and available in the modified version of the game.
-However, getting Extreme Landings Windows Crack Key for free is not easy or safe. You will need to find a reliable source on the internet that provides the crack key and the modified version of the game. You will also need to download an Android emulator on your PC that allows you to run Android apps and games on your PC. You will also need to install and launch the Android emulator on your PC, drag and drop the APK file into the emulator window, or use the built-in browser to locate and install it. You will also need to launch Extreme Landings Pro from the emulator home screen and enjoy playing Extreme Landings Windows Crack Key on your PC.
-What are some tips and tricks for playing Extreme Landings Windows Crack Key?
-Extreme Landings Windows Crack Key is not just a fun game, but a challenging one. You will need to master some tips and tricks to play it well and complete all the missions and challenges. Here are some suggestions:
-
-- Use the navigation bar: The navigation bar will help you keep track of your flight path, altitude, speed, fuel level, weather conditions, and other important information. You can also use it to turn on or off autopilot, review your route, control your speed level, and adjust your settings.
-- Manage your engine system: The engine system is vital for your aircraft's performance and safety. You will need to monitor its status and temperature, manage its fuel consumption, activate its APU mode, and deal with any failures or malfunctions that might occur.
-- Operate your landing gear: The landing gear is essential for your aircraft's takeoff and landing. You will need to open or close it within the allowable range, use the brakes properly, check its condition and damage level, and coordinate it with the flap system and reverse.
-- Practice in different modes: The game offers different modes for you to practice and improve your skills. You can try the free flight mode to explore different locations and scenarios without any pressure or objectives. You can also try the landing competition mode to test your landing accuracy and precision against other players online.
-
-What are some reviews and ratings for Extreme Landings Windows Crack Key?
-Extreme Landings Windows Crack Key is not just a game, but a community. You can share your opinions and feedback with other players online, and read their reviews and ratings for the game. You can also learn from their tips and tricks, and discover their favorite features and functions of the game.
-However, finding reviews and ratings for Extreme Landings Windows Crack Key is not easy or reliable. You will need to search for them on the internet, and filter out the ones that are fake, biased, or outdated. You will also need to be careful of the sources that provide the reviews and ratings, as they might be infected with malware or viruses that can harm your PC or steal your data.
-Here are some examples of reviews and ratings for Extreme Landings Windows Crack Key from different sources:
-
-- Reddit: A user named SoonlyXo posted a question on r/PiratedGames, asking where or how to crack Extreme Landings Pro for Windows 10. The user received some replies from other users, suggesting to use a cracked Android version of the game, or to download an IPA file from a website. The user also received a comment from AutoModerator, a bot that reminded them to read the stickied megathread that might answer their question. The post received 2 upvotes and 6 comments.
-- SoundCloud: A user named Tracourytsmal1984 uploaded a track titled Extreme Landings Windows Crack Key, which is a 3-minute audio file that contains instructions on how to download and install the game on PC. The user also provided a link to a PDF file that contains more information about the game. The track received no likes or comments.
-- MODYOLO: A website that provides APK and MOD files for Android games and apps. The website has a page for Extreme Landings Pro v3.7.8 APK + MOD (All Unlocked), which is a modified version of the game that has all the content unlocked and does not require a license. The page contains a brief introduction of the game, its features, its mod info, its screenshots, and its download links. The page also has a comment section where users can leave their feedback or ask questions about the game. The page received no ratings or comments.
-
-How to update Extreme Landings Windows Crack Key?
-Extreme Landings Windows Crack Key is not just a game, but a project. You can expect new updates and improvements for the game from time to time, as the developer and publisher might release new versions of the game that fix bugs, add features, or enhance performance. You can also enjoy new content and challenges that are added to the game with each update.
-However, updating Extreme Landings Windows Crack Key is not easy or automatic. You will need to manually check for updates on the internet, and download and install them on your PC. You will also need to make sure that the updates are compatible with your crack key and your modified version of the game. You might also need to backup your data and settings before updating, as they might be overwritten or deleted by the update.
-Here are some steps to update Extreme Landings Windows Crack Key on your PC:
-
-- Visit the official website of Extreme Landings Pro or follow its social media accounts to check for any news or announcements about new updates for the game.
-- If there is a new update available, find a reliable source on the internet that provides the update file for Extreme Landings Windows Crack Key.
-- Download the update file on your PC, and scan it with an antivirus software to make sure it is safe and clean.
-- Backup your data and settings of Extreme Landings Windows Crack Key on your PC, such as your progress, achievements, preferences, etc.
-- Close Extreme Landings Pro if it is running on your PC.
-- Run the update file on your PC, and follow the instructions to install it.
-- Launch Extreme Landings Pro from your Android emulator home screen.
-- Enjoy playing Extreme Landings Windows Crack Key with the latest update.
-
-Conclusion
-In conclusion, Extreme Landings Windows Crack Key is a way to play Extreme Landings Pro on your Windows 10 PC for free by using a modified version of the game that bypasses the security measures. However, using a crack key is illegal, unethical, risky, and potentially harmful for your PC and the game quality and performance. If you want to enjoy a flight simulation game on your PC, you should consider some alternatives that are similar or better than Extreme Landings Pro, such as Microsoft Flight Simulator, X-Plane 11, or Aerofly FS 2020. These games are officially available for Windows 10 or other platforms, and offer a more realistic, immersive, and satisfying flight simulation experience.
3cee63e6c2
-
-
\ No newline at end of file
diff --git a/spaces/group2test/stable-diffusion-v1-5/app.py b/spaces/group2test/stable-diffusion-v1-5/app.py
deleted file mode 100644
index 2013a8fe01c8fdf93c87412e5f9c83d9c8501b5b..0000000000000000000000000000000000000000
--- a/spaces/group2test/stable-diffusion-v1-5/app.py
+++ /dev/null
@@ -1,137 +0,0 @@
-from diffusers import StableDiffusionPipeline, StableDiffusionImg2ImgPipeline, DPMSolverMultistepScheduler
-import gradio as gr
-import torch
-from PIL import Image
-
-model_id = 'runwayml/stable-diffusion-v1-5'
-prefix = ''
-
-scheduler = DPMSolverMultistepScheduler.from_pretrained(model_id, subfolder="scheduler")
-
-pipe = StableDiffusionPipeline.from_pretrained(
- model_id,
- torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
- scheduler=scheduler)
-
-pipe_i2i = StableDiffusionImg2ImgPipeline.from_pretrained(
- model_id,
- torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
- scheduler=scheduler)
-
-if torch.cuda.is_available():
- pipe = pipe.to("cuda")
- pipe_i2i = pipe_i2i.to("cuda")
-
-def error_str(error, title="Error"):
- return f"""#### {title}
- {error}""" if error else ""
-
-def inference(prompt, guidance, steps, width=512, height=512, seed=0, img=None, strength=0.5, neg_prompt="", auto_prefix=False):
-
- generator = torch.Generator('cuda').manual_seed(seed) if seed != 0 else None
- prompt = f"{prefix} {prompt}" if auto_prefix else prompt
-
- try:
- if img is not None:
- return img_to_img(prompt, neg_prompt, img, strength, guidance, steps, width, height, generator), None
- else:
- return txt_to_img(prompt, neg_prompt, guidance, steps, width, height, generator), None
- except Exception as e:
- return None, error_str(e)
-
-def txt_to_img(prompt, neg_prompt, guidance, steps, width, height, generator):
-
- result = pipe(
- prompt,
- negative_prompt = neg_prompt,
- num_inference_steps = int(steps),
- guidance_scale = guidance,
- width = width,
- height = height,
- generator = generator)
-
- return result.images[0]
-
-def img_to_img(prompt, neg_prompt, img, strength, guidance, steps, width, height, generator):
-
- ratio = min(height / img.height, width / img.width)
- img = img.resize((int(img.width * ratio), int(img.height * ratio)), Image.LANCZOS)
- result = pipe_i2i(
- prompt,
- negative_prompt = neg_prompt,
- init_image = img,
- num_inference_steps = int(steps),
- strength = strength,
- guidance_scale = guidance,
- width = width,
- height = height,
- generator = generator)
-
- return result.images[0]
-
-css = """.main-div div{display:inline-flex;align-items:center;gap:.8rem;font-size:1.75rem}.main-div div h1{font-weight:900;margin-bottom:7px}.main-div p{margin-bottom:10px;font-size:94%}a{text-decoration:underline}.tabs{margin-top:0;margin-bottom:0}#gallery{min-height:20rem}
-"""
-with gr.Blocks(css=css) as demo:
- gr.HTML(
- f"""
-
-
- Stable Diffusion V1 5
-
-
- Demo for Stable Diffusion V1 5 Stable Diffusion model.
- {"Add the following tokens to your prompts for the model to work properly: prefix" if prefix else ""}
-
- Running on {"GPU 🔥" if torch.cuda.is_available() else f"CPU 🥶. For faster inference it is recommended to upgrade to GPU in Settings"} after duplicating the space
- 
-
- """
- )
- with gr.Row():
-
- with gr.Column(scale=55):
- with gr.Group():
- with gr.Row():
- prompt = gr.Textbox(label="Prompt", show_label=False, max_lines=2,placeholder=f"{prefix} [your prompt]").style(container=False)
- generate = gr.Button(value="Generate").style(rounded=(False, True, True, False))
-
- image_out = gr.Image(height=512)
- error_output = gr.Markdown()
-
- with gr.Column(scale=45):
- with gr.Tab("Options"):
- with gr.Group():
- neg_prompt = gr.Textbox(label="Negative prompt", placeholder="What to exclude from the image")
- auto_prefix = gr.Checkbox(label="Prefix styling tokens automatically ()", value=prefix, visible=prefix)
-
- with gr.Row():
- guidance = gr.Slider(label="Guidance scale", value=7.5, maximum=15)
- steps = gr.Slider(label="Steps", value=25, minimum=2, maximum=75, step=1)
-
- with gr.Row():
- width = gr.Slider(label="Width", value=512, minimum=64, maximum=1024, step=8)
- height = gr.Slider(label="Height", value=512, minimum=64, maximum=1024, step=8)
-
- seed = gr.Slider(0, 2147483647, label='Seed (0 = random)', value=0, step=1)
-
- with gr.Tab("Image to image"):
- with gr.Group():
- image = gr.Image(label="Image", height=256, tool="editor", type="pil")
- strength = gr.Slider(label="Transformation strength", minimum=0, maximum=1, step=0.01, value=0.5)
-
- auto_prefix.change(lambda x: gr.update(placeholder=f"{prefix} [your prompt]" if x else "[Your prompt]"), inputs=auto_prefix, outputs=prompt, queue=False)
-
- inputs = [prompt, guidance, steps, width, height, seed, image, strength, neg_prompt, auto_prefix]
- outputs = [image_out, error_output]
- prompt.submit(inference, inputs=inputs, outputs=outputs)
- generate.click(inference, inputs=inputs, outputs=outputs)
-
- gr.HTML("""
-
-
- This space was created using SD Space Creator.
-
- """)
-
-demo.queue(concurrency_count=1)
-demo.launch()
diff --git a/spaces/gsaivinay/open_llm_leaderboard/src/display_models/get_model_metadata.py b/spaces/gsaivinay/open_llm_leaderboard/src/display_models/get_model_metadata.py
deleted file mode 100644
index ebeee76061650664b00259fe980ce05f013a0e9c..0000000000000000000000000000000000000000
--- a/spaces/gsaivinay/open_llm_leaderboard/src/display_models/get_model_metadata.py
+++ /dev/null
@@ -1,180 +0,0 @@
-import glob
-import json
-import os
-import pickle
-import re
-from typing import List
-
-import huggingface_hub
-from accelerate import init_empty_weights
-from huggingface_hub import HfApi
-from tqdm import tqdm
-from transformers import AutoConfig, AutoModel
-
-from src.display_models.model_metadata_flags import DO_NOT_SUBMIT_MODELS, FLAGGED_MODELS
-from src.display_models.model_metadata_type import MODEL_TYPE_METADATA, ModelType, model_type_from_str
-from src.display_models.utils import AutoEvalColumn, model_hyperlink
-
-api = HfApi(token=os.environ.get("H4_TOKEN", None))
-
-
-def get_model_infos_from_hub(leaderboard_data: List[dict]):
- # load cache from disk
- try:
- with open("model_info_cache.pkl", "rb") as f:
- model_info_cache = pickle.load(f)
- except (EOFError, FileNotFoundError):
- model_info_cache = {}
- try:
- with open("model_size_cache.pkl", "rb") as f:
- model_size_cache = pickle.load(f)
- except (EOFError, FileNotFoundError):
- model_size_cache = {}
- try:
- with open("model_size_cache.pkl", "rb") as f:
- model_size_cache = pickle.load(f)
- except (EOFError, FileNotFoundError):
- model_size_cache = {}
-
- for model_data in tqdm(leaderboard_data):
- model_name = model_data["model_name_for_query"]
-
- if model_name in model_info_cache:
- model_info = model_info_cache[model_name]
- else:
- try:
- model_info = api.model_info(model_name)
- model_info_cache[model_name] = model_info
- except huggingface_hub.utils._errors.RepositoryNotFoundError:
- print("Repo not found!", model_name)
- model_data[AutoEvalColumn.license.name] = None
- model_data[AutoEvalColumn.likes.name] = None
- if model_name not in model_size_cache:
- model_size_cache[model_name] = get_model_size(model_name, None)
- model_data[AutoEvalColumn.params.name] = model_size_cache[model_name]
- if model_name not in model_size_cache:
- model_size_cache[model_name] = get_model_size(model_name, None)
- model_data[AutoEvalColumn.params.name] = model_size_cache[model_name]
-
- model_data[AutoEvalColumn.license.name] = get_model_license(model_info)
- model_data[AutoEvalColumn.likes.name] = get_model_likes(model_info)
- if model_name not in model_size_cache:
- model_size_cache[model_name] = get_model_size(model_name, model_info)
- model_data[AutoEvalColumn.params.name] = model_size_cache[model_name]
- if model_name not in model_size_cache:
- model_size_cache[model_name] = get_model_size(model_name, model_info)
- model_data[AutoEvalColumn.params.name] = model_size_cache[model_name]
-
- # save cache to disk in pickle format
- with open("model_info_cache.pkl", "wb") as f:
- pickle.dump(model_info_cache, f)
- with open("model_size_cache.pkl", "wb") as f:
- pickle.dump(model_size_cache, f)
- with open("model_size_cache.pkl", "wb") as f:
- pickle.dump(model_size_cache, f)
-
-
-def get_model_license(model_info):
- try:
- return model_info.cardData["license"]
- except Exception:
- return "?"
-
-
-def get_model_likes(model_info):
- return model_info.likes
-
-
-size_pattern = re.compile(r"(\d\.)?\d+(b|m)")
-
-
-def get_model_size(model_name, model_info):
- # In billions
- try:
- return round(model_info.safetensors["total"] / 1e9, 3)
- except AttributeError:
- try:
- config = AutoConfig.from_pretrained(model_name, trust_remote_code=False)
- with init_empty_weights():
- model = AutoModel.from_config(config, trust_remote_code=False)
- return round(sum(p.numel() for p in model.parameters() if p.requires_grad) / 1e9, 3)
- except (EnvironmentError, ValueError, KeyError): # model config not found, likely private
- try:
- size_match = re.search(size_pattern, model_name.lower())
- size = size_match.group(0)
- return round(float(size[:-1]) if size[-1] == "b" else float(size[:-1]) / 1e3, 3)
- except AttributeError:
- return 0
-
-
-def get_model_type(leaderboard_data: List[dict]):
- for model_data in leaderboard_data:
- request_files = os.path.join(
- "eval-queue",
- model_data["model_name_for_query"] + "_eval_request_*" + ".json",
- )
- request_files = glob.glob(request_files)
-
- # Select correct request file (precision)
- request_file = ""
- if len(request_files) == 1:
- request_file = request_files[0]
- elif len(request_files) > 1:
- request_files = sorted(request_files, reverse=True)
- for tmp_request_file in request_files:
- with open(tmp_request_file, "r") as f:
- req_content = json.load(f)
- if (
- req_content["status"] == "FINISHED"
- and req_content["precision"] == model_data["Precision"].split(".")[-1]
- ):
- request_file = tmp_request_file
-
- try:
- with open(request_file, "r") as f:
- request = json.load(f)
- model_type = model_type_from_str(request["model_type"])
- model_data[AutoEvalColumn.model_type.name] = model_type.value.name
- model_data[AutoEvalColumn.model_type_symbol.name] = model_type.value.symbol # + ("🔺" if is_delta else "")
- except Exception:
- if model_data["model_name_for_query"] in MODEL_TYPE_METADATA:
- model_data[AutoEvalColumn.model_type.name] = MODEL_TYPE_METADATA[
- model_data["model_name_for_query"]
- ].value.name
- model_data[AutoEvalColumn.model_type_symbol.name] = MODEL_TYPE_METADATA[
- model_data["model_name_for_query"]
- ].value.symbol # + ("🔺" if is_delta else "")
- else:
- model_data[AutoEvalColumn.model_type.name] = ModelType.Unknown.value.name
- model_data[AutoEvalColumn.model_type_symbol.name] = ModelType.Unknown.value.symbol
-
-
-def flag_models(leaderboard_data: List[dict]):
- for model_data in leaderboard_data:
- if model_data["model_name_for_query"] in FLAGGED_MODELS:
- issue_num = FLAGGED_MODELS[model_data["model_name_for_query"]].split("/")[-1]
- issue_link = model_hyperlink(
- FLAGGED_MODELS[model_data["model_name_for_query"]],
- f"See discussion #{issue_num}",
- )
- model_data[
- AutoEvalColumn.model.name
- ] = f"{model_data[AutoEvalColumn.model.name]} has been flagged! {issue_link}"
-
-
-def remove_forbidden_models(leaderboard_data: List[dict]):
- indices_to_remove = []
- for ix, model in enumerate(leaderboard_data):
- if model["model_name_for_query"] in DO_NOT_SUBMIT_MODELS:
- indices_to_remove.append(ix)
-
- for ix in reversed(indices_to_remove):
- leaderboard_data.pop(ix)
- return leaderboard_data
-
-
-def apply_metadata(leaderboard_data: List[dict]):
- leaderboard_data = remove_forbidden_models(leaderboard_data)
- get_model_type(leaderboard_data)
- get_model_infos_from_hub(leaderboard_data)
- flag_models(leaderboard_data)
diff --git a/spaces/gwang-kim/DATID-3D/pose_estimation/nvdiffrast/setup.py b/spaces/gwang-kim/DATID-3D/pose_estimation/nvdiffrast/setup.py
deleted file mode 100644
index 889c87521642305e62815f32d6a42c7b307852a0..0000000000000000000000000000000000000000
--- a/spaces/gwang-kim/DATID-3D/pose_estimation/nvdiffrast/setup.py
+++ /dev/null
@@ -1,46 +0,0 @@
-# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
-#
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto. Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-from pose_estimation.nvdiffrast import nvdiffrast
-import setuptools
-import os
-
-with open("README.md", "r") as fh:
- long_description = fh.read()
-
-setuptools.setup(
- name="nvdiffrast",
- version=nvdiffrast.__version__,
- author="Samuli Laine",
- author_email="slaine@nvidia.com",
- description="nvdiffrast - modular primitives for high-performance differentiable rendering",
- long_description=long_description,
- long_description_content_type="text/markdown",
- url="https://github.com/NVlabs/nvdiffrast",
- packages=setuptools.find_packages(),
- package_data={
- 'nvdiffrast': [
- 'common/*.h',
- 'common/*.inl',
- 'common/*.cu',
- 'common/*.cpp',
- 'lib/*.h',
- 'torch/*.h',
- 'torch/*.inl',
- 'torch/*.cpp',
- 'tensorflow/*.cu',
- ] + (['lib/*.lib'] if os.name == 'nt' else [])
- },
- include_package_data=True,
- install_requires=['numpy'], # note: can't require torch here as it will install torch even for a TensorFlow container
- classifiers=[
- "Programming Language :: Python :: 3",
- "Operating System :: OS Independent",
- ],
- python_requires='>=3.6',
-)
diff --git a/spaces/gyugnsu/DragGan-Inversion/stylegan_human/pti/pti_configs/__init__.py b/spaces/gyugnsu/DragGan-Inversion/stylegan_human/pti/pti_configs/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/haakohu/deep_privacy2/configs/fdf/stylegan_fdf128.py b/spaces/haakohu/deep_privacy2/configs/fdf/stylegan_fdf128.py
deleted file mode 100644
index a47d6d2ee362c935e7879c9442c4dcd9aaf007c0..0000000000000000000000000000000000000000
--- a/spaces/haakohu/deep_privacy2/configs/fdf/stylegan_fdf128.py
+++ /dev/null
@@ -1,17 +0,0 @@
-from ..discriminators.sg2_discriminator import discriminator, G_optim, D_optim, loss_fnc
-from ..datasets.fdf128 import data
-from ..generators.stylegan_unet import generator
-from ..defaults import train, common, EMA
-from tops.config import LazyCall as L
-
-G_optim.lr = 0.002
-D_optim.lr = 0.002
-generator.update(cnum=128, max_cnum_mul=4, input_cse=False)
-loss_fnc.r1_opts.lambd = 0.1
-
-train.update(ims_per_val=int(2e6), batch_size=64, max_images_to_train=int(35e6))
-
-common.update(
- model_url="https://api.loke.aws.unit.no/dlr-gui-backend-resources-content/v2/contents/links/66d803c0-55ce-44c0-9d53-815c2c0e6ba4eb458409-9e91-45d1-bce0-95c8a47a57218b102fdf-bea3-44dc-aac4-0fb1d370ef1c",
- model_md5sum="bccd4403e7c9bca682566ff3319e8176"
-)
\ No newline at end of file
diff --git a/spaces/hahahafofo/image2text_prompt_generator/utils/exif.py b/spaces/hahahafofo/image2text_prompt_generator/utils/exif.py
deleted file mode 100644
index fef7a34cc83697a32b25eef46a776dfe4228977b..0000000000000000000000000000000000000000
--- a/spaces/hahahafofo/image2text_prompt_generator/utils/exif.py
+++ /dev/null
@@ -1,54 +0,0 @@
-import piexif
-import piexif.helper
-from .html import plaintext_to_html
-
-
-def get_image_info(rawimage):
- items = rawimage.info
- geninfo = ""
-
- if "exif" in rawimage.info:
- exif = piexif.load(rawimage.info["exif"])
- exif_comment = (exif or {}).get("Exif", {}).get(piexif.ExifIFD.UserComment, b"")
- try:
- exif_comment = piexif.helper.UserComment.load(exif_comment)
- except ValueError:
- exif_comment = exif_comment.decode("utf8", errors="ignore")
-
- items["exif comment"] = exif_comment
- geninfo = exif_comment
-
- for field in [
- "jfif",
- "jfif_version",
- "jfif_unit",
- "jfif_density",
- "dpi",
- "exif",
- "loop",
- "background",
- "timestamp",
- "duration",
- ]:
- items.pop(field, None)
-
- geninfo = items.get("parameters", geninfo)
-
- info = f"""
- PNG Info
- """
- for key, text in items.items():
- info += (
- f"""
-
- {plaintext_to_html(str(key))}
- {plaintext_to_html(str(text))}
-
- """.strip()
- + "\n"
- )
-
- if len(info) == 0:
- message = "Nothing found in the image."
- info = f"{message}
"
- return info
diff --git a/spaces/hamzapehlivan/StyleRes/models/e4e.py b/spaces/hamzapehlivan/StyleRes/models/e4e.py
deleted file mode 100644
index 9b7247baf03fe27972b3b434b6270cee1a9ccc05..0000000000000000000000000000000000000000
--- a/spaces/hamzapehlivan/StyleRes/models/e4e.py
+++ /dev/null
@@ -1,348 +0,0 @@
-import math
-import numpy as np
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from collections import namedtuple
-
-def _upsample_add(x, y):
- _, _, H, W = y.size()
- return F.interpolate(x, size=(H, W), mode='bilinear', align_corners=True) + y
-
-
-
-class EqualLinear(nn.Module):
- def __init__(
- self, in_dim, out_dim, bias=True, bias_init=0, lr_mul=1, activation=None
- ):
- super().__init__()
-
- self.weight = nn.Parameter(torch.randn(out_dim, in_dim).div_(lr_mul))
-
- if bias:
- self.bias = nn.Parameter(torch.zeros(out_dim).fill_(bias_init))
-
- else:
- self.bias = None
-
- self.activation = activation
-
- self.scale = (1 / math.sqrt(in_dim)) * lr_mul
- self.lr_mul = lr_mul
-
- def forward(self, input):
- # if self.activation:
- # out = F.linear(input, self.weight * self.scale)
- # out = fused_leaky_relu(out, self.bias * self.lr_mul)
-
- # else:
- out = F.linear(
- input, self.weight * self.scale, bias=self.bias * self.lr_mul
- )
-
- return out
-
- def __repr__(self):
- return (
- f'{self.__class__.__name__}({self.weight.shape[1]}, {self.weight.shape[0]})'
- )
-
-class GradualStyleBlock(nn.Module):
- def __init__(self, in_c, out_c, spatial):
- super(GradualStyleBlock, self).__init__()
- self.out_c = out_c
- self.spatial = spatial
- num_pools = int(np.log2(spatial))
- modules = []
- modules += [nn.Conv2d(in_c, out_c, kernel_size=3, stride=2, padding=1),
- nn.LeakyReLU()]
- for i in range(num_pools - 1):
- modules += [
- nn.Conv2d(out_c, out_c, kernel_size=3, stride=2, padding=1),
- nn.LeakyReLU()
- ]
- self.convs = nn.Sequential(*modules)
- self.linear = EqualLinear(out_c, out_c, lr_mul=1)
-
- def forward(self, x):
- x = self.convs(x)
- x = x.view(-1, self.out_c)
- x = self.linear(x)
- return x
-
-class Bottleneck(namedtuple('Block', ['in_channel', 'depth', 'stride'])):
- """ A named tuple describing a ResNet block. """
-
-class bottleneck_IR(nn.Module):
- def __init__(self, in_channel, depth, stride):
- super(bottleneck_IR, self).__init__()
- if in_channel == depth:
- self.shortcut_layer = nn.MaxPool2d(1, stride)
- else:
- self.shortcut_layer = nn.Sequential(
- nn.Conv2d(in_channel, depth, (1, 1), stride, bias=False),
- nn.BatchNorm2d(depth)
- )
- self.res_layer = nn.Sequential(
- nn.BatchNorm2d(in_channel),
- nn.Conv2d(in_channel, depth, (3, 3), (1, 1), 1, bias=False), nn.PReLU(depth),
- nn.Conv2d(depth, depth, (3, 3), stride, 1, bias=False), nn.BatchNorm2d(depth)
- )
-
- def forward(self, x):
- shortcut = self.shortcut_layer(x)
- res = self.res_layer(x)
- return res + shortcut
-
-class SEModule(nn.Module):
- def __init__(self, channels, reduction):
- super(SEModule, self).__init__()
- self.avg_pool = nn.AdaptiveAvgPool2d(1)
- self.fc1 = nn.Conv2d(channels, channels // reduction, kernel_size=1, padding=0, bias=False)
- self.relu = nn.ReLU(inplace=True)
- self.fc2 = nn.Conv2d(channels // reduction, channels, kernel_size=1, padding=0, bias=False)
- self.sigmoid = nn.Sigmoid()
-
- def forward(self, x):
- module_input = x
- x = self.avg_pool(x)
- x = self.fc1(x)
- x = self.relu(x)
- x = self.fc2(x)
- x = self.sigmoid(x)
- return module_input * x
-
-class bottleneck_IR_SE(nn.Module):
- def __init__(self, in_channel, depth, stride):
- super(bottleneck_IR_SE, self).__init__()
- if in_channel == depth:
- self.shortcut_layer = nn.MaxPool2d(1, stride)
- else:
- self.shortcut_layer = nn.Sequential(
- nn.Conv2d(in_channel, depth, (1, 1), stride, bias=False),
- nn.BatchNorm2d(depth)
- )
- self.res_layer = nn.Sequential(
- nn.BatchNorm2d(in_channel),
- nn.Conv2d(in_channel, depth, (3, 3), (1, 1), 1, bias=False),
- nn.PReLU(depth),
- nn.Conv2d(depth, depth, (3, 3), stride, 1, bias=False),
- nn.BatchNorm2d(depth),
- SEModule(depth, 16)
- )
-
- def forward(self, x):
- shortcut = self.shortcut_layer(x)
- res = self.res_layer(x)
- return res + shortcut
-
-
-def get_block(in_channel, depth, num_units, stride=2):
- return [Bottleneck(in_channel, depth, stride)] + [Bottleneck(depth, depth, 1) for i in range(num_units - 1)]
-
-def get_blocks(num_layers):
- if num_layers == 50:
- blocks = [
- get_block(in_channel=64, depth=64, num_units=3),
- get_block(in_channel=64, depth=128, num_units=4),
- get_block(in_channel=128, depth=256, num_units=14),
- get_block(in_channel=256, depth=512, num_units=3)
- ]
- elif num_layers == 100:
- blocks = [
- get_block(in_channel=64, depth=64, num_units=3),
- get_block(in_channel=64, depth=128, num_units=13),
- get_block(in_channel=128, depth=256, num_units=30),
- get_block(in_channel=256, depth=512, num_units=3)
- ]
- elif num_layers == 152:
- blocks = [
- get_block(in_channel=64, depth=64, num_units=3),
- get_block(in_channel=64, depth=128, num_units=8),
- get_block(in_channel=128, depth=256, num_units=36),
- get_block(in_channel=256, depth=512, num_units=3)
- ]
- else:
- raise ValueError("Invalid number of layers: {}. Must be one of [50, 100, 152]".format(num_layers))
- return blocks
-
-class Encoder4Editing(nn.Module):
- def __init__(self, num_layers, mode='ir', stylegan_size=1024, out_res=64):
- super(Encoder4Editing, self).__init__()
- assert num_layers in [50, 100, 152], 'num_layers should be 50,100, or 152'
- assert mode in ['ir', 'ir_se'], 'mode should be ir or ir_se'
- blocks = get_blocks(num_layers)
- if mode == 'ir':
- unit_module = bottleneck_IR
- elif mode == 'ir_se':
- unit_module = bottleneck_IR_SE
- self.out_res = out_res
- self.input_layer = nn.Sequential(nn.Conv2d(3, 64, (3, 3), 1, 1, bias=False),
- nn.BatchNorm2d(64),
- nn.PReLU(64))
- modules = []
- for block in blocks:
- for bottleneck in block:
- modules.append(unit_module(bottleneck.in_channel,
- bottleneck.depth,
- bottleneck.stride))
- self.body = nn.Sequential(*modules)
-
- self.styles = nn.ModuleList()
- log_size = int(math.log(stylegan_size, 2))
- self.style_count = 2 * log_size - 2
- self.coarse_ind = 3
- self.middle_ind = 7
-
- for i in range(self.style_count):
- if i < self.coarse_ind:
- style = GradualStyleBlock(512, 512, 16)
- elif i < self.middle_ind:
- style = GradualStyleBlock(512, 512, 32)
- else:
- style = GradualStyleBlock(512, 512, 64)
- self.styles.append(style)
-
- self.latlayer1 = nn.Conv2d(256, 512, kernel_size=1, stride=1, padding=0)
- self.latlayer2 = nn.Conv2d(128, 512, kernel_size=1, stride=1, padding=0)
-
- def forward(self, x):
- x = self.input_layer(x)
-
- modulelist = list(self.body._modules.values())
- for i, l in enumerate(modulelist):
- x = l(x)
- if i == 2:
- c0 = x
- if i == 6:
- c1 = x
- elif i == 20:
- c2 = x
- elif i == 23:
- c3 = x
-
- # Infer main W and duplicate it
- w0 = self.styles[0](c3)
- w = w0.repeat(self.style_count, 1, 1).permute(1, 0, 2)
-
- features = c3
- for i in range(1, self.style_count): # Infer additional deltas
- if i == self.coarse_ind:
- p2 = _upsample_add(c3, self.latlayer1(c2)) # FPN's middle features
- features = p2
- elif i == self.middle_ind:
- p1 = _upsample_add(p2, self.latlayer2(c1)) # FPN's fine features
- features = p1
- delta_i = self.styles[i](features)
- w[:, i] += delta_i
-
- c = { 128: c0,
- 64: c1,
- 32: c2,
- 16: c3
- }.get(self.out_res)
- return w, c
-
-class EqualConv2d(nn.Module):
- def __init__(
- self, in_channel, out_channel, kernel_size, stride=1, padding=0, bias=True
- ):
- super().__init__()
-
- self.weight = nn.Parameter(
- torch.randn(out_channel, in_channel, kernel_size, kernel_size)
- )
- self.scale = 1 / math.sqrt(in_channel * kernel_size ** 2)
-
- self.stride = stride
- self.padding = padding
-
- if bias:
- self.bias = nn.Parameter(torch.zeros(out_channel))
-
- else:
- self.bias = None
-
- def forward(self, input):
- out = F.conv2d(
- input,
- self.weight * self.scale,
- bias=self.bias,
- stride=self.stride,
- padding=self.padding,
- )
-
- return out
-
- def __repr__(self):
- return (
- f'{self.__class__.__name__}({self.weight.shape[1]}, {self.weight.shape[0]},'
- f' {self.weight.shape[2]}, stride={self.stride}, padding={self.padding})'
- )
-
-class ScaledLeakyReLU(nn.Module):
- def __init__(self, negative_slope=0.2):
- super().__init__()
-
- self.negative_slope = negative_slope
-
- def forward(self, input):
- out = F.leaky_relu(input, negative_slope=self.negative_slope)
-
- return out * math.sqrt(2)
-
-class HighResFeat(nn.Module):
- def __init__(self, in_channels, out_channels):
- super(HighResFeat, self).__init__()
-
- self.shared = EqualConv2d(in_channels, out_channels, kernel_size=3, padding=1, bias=True)
-
- self.conv1 = EqualConv2d(out_channels, 1, kernel_size=3, padding=1, bias=True)
- self.conv2 = EqualConv2d(out_channels, out_channels, kernel_size=3, padding=1, bias=True)
- self.activation = ScaledLeakyReLU(0.2)
-
- self.sigmoid = nn.Sigmoid()
-
- self.skip = None
- if in_channels != out_channels:
- self.skip = EqualConv2d(in_channels, out_channels, kernel_size=1, padding=0, bias=False)
-
- def forward(self, x):
-
- shared_feats = self.shared(x)
- shared_feats = self.activation(shared_feats)
-
- gate = self.conv1(shared_feats)
- gate = self.sigmoid(gate)
-
- addition = self.conv2(shared_feats)
- addition = self.activation(addition)
-
- if self.skip is not None:
- x = self.skip(x)
- return gate, addition+x
-
-class E4E_Inversion(nn.Module):
- def __init__(self, resolution, num_layers = 50, mode='ir_se', out_res=64):
- super(E4E_Inversion, self).__init__()
- self.out_res = out_res
- resolution = 1024
- self.basic_encoder = Encoder4Editing(num_layers, mode, resolution, self.out_res)
- self.latent_avg = None
- # ckpt = torch.load(e4e_path, map_location='cpu')
- # self.latent_avg = ckpt['latent_avg'].cuda()
- # ckpt = {k[k.find(".")+1:]: v for k, v in ckpt['state_dict'].items() if "decoder" not in k}
- # self.basic_encoder.load_state_dict(ckpt, strict=True)
-
- def freeze_basic_encoder(self):
- self.basic_encoder.eval() #Basic Encoder always in eval mode.
- #No backprop to basic Encoder
- for param in self.basic_encoder.parameters():
- param.requires_grad = False
-
- def forward(self, reals):
- self.freeze_basic_encoder()
- w, c = self.basic_encoder(reals)
- w = w + self.latent_avg
- highres_outs = {f"{self.out_res}x{self.out_res}": c} #{"gates": gates, "additions": additions}
- return w, highres_outs
diff --git a/spaces/hands012/gpt-academic/crazy_functions/test_project/cpp/cppipc/prod_cons.h b/spaces/hands012/gpt-academic/crazy_functions/test_project/cpp/cppipc/prod_cons.h
deleted file mode 100644
index c9004bb8043a12e32814436baa6262a00c8ef68e..0000000000000000000000000000000000000000
--- a/spaces/hands012/gpt-academic/crazy_functions/test_project/cpp/cppipc/prod_cons.h
+++ /dev/null
@@ -1,433 +0,0 @@
-#pragma once
-
-#include
-#include
-#include
-#include
-#include
-
-#include "libipc/def.h"
-
-#include "libipc/platform/detail.h"
-#include "libipc/circ/elem_def.h"
-#include "libipc/utility/log.h"
-#include "libipc/utility/utility.h"
-
-namespace ipc {
-
-////////////////////////////////////////////////////////////////
-/// producer-consumer implementation
-////////////////////////////////////////////////////////////////
-
-template
-struct prod_cons_impl;
-
-template <>
-struct prod_cons_impl> {
-
- template
- struct elem_t {
- std::aligned_storage_t data_ {};
- };
-
- alignas(cache_line_size) std::atomic rd_; // read index
- alignas(cache_line_size) std::atomic wt_; // write index
-
- constexpr circ::u2_t cursor() const noexcept {
- return 0;
- }
-
- template
- bool push(W* /*wrapper*/, F&& f, E* elems) {
- auto cur_wt = circ::index_of(wt_.load(std::memory_order_relaxed));
- if (cur_wt == circ::index_of(rd_.load(std::memory_order_acquire) - 1)) {
- return false; // full
- }
- std::forward(f)(&(elems[cur_wt].data_));
- wt_.fetch_add(1, std::memory_order_release);
- return true;
- }
-
- /**
- * In single-single-unicast, 'force_push' means 'no reader' or 'the only one reader is dead'.
- * So we could just disconnect all connections of receiver, and return false.
- */
- template
- bool force_push(W* wrapper, F&&, E*) {
- wrapper->elems()->disconnect_receiver(~static_cast(0u));
- return false;
- }
-
- template
- bool pop(W* /*wrapper*/, circ::u2_t& /*cur*/, F&& f, R&& out, E* elems) {
- auto cur_rd = circ::index_of(rd_.load(std::memory_order_relaxed));
- if (cur_rd == circ::index_of(wt_.load(std::memory_order_acquire))) {
- return false; // empty
- }
- std::forward(f)(&(elems[cur_rd].data_));
- std::forward(out)(true);
- rd_.fetch_add(1, std::memory_order_release);
- return true;
- }
-};
-
-template <>
-struct prod_cons_impl>
- : prod_cons_impl> {
-
- template
- bool force_push(W* wrapper, F&&, E*) {
- wrapper->elems()->disconnect_receiver(1);
- return false;
- }
-
- template class E, std::size_t DS, std::size_t AS>
- bool pop(W* /*wrapper*/, circ::u2_t& /*cur*/, F&& f, R&& out, E* elems) {
- byte_t buff[DS];
- for (unsigned k = 0;;) {
- auto cur_rd = rd_.load(std::memory_order_relaxed);
- if (circ::index_of(cur_rd) ==
- circ::index_of(wt_.load(std::memory_order_acquire))) {
- return false; // empty
- }
- std::memcpy(buff, &(elems[circ::index_of(cur_rd)].data_), sizeof(buff));
- if (rd_.compare_exchange_weak(cur_rd, cur_rd + 1, std::memory_order_release)) {
- std::forward(f)(buff);
- std::forward(out)(true);
- return true;
- }
- ipc::yield(k);
- }
- }
-};
-
-template <>
-struct prod_cons_impl>
- : prod_cons_impl> {
-
- using flag_t = std::uint64_t;
-
- template
- struct elem_t {
- std::aligned_storage_t data_ {};
- std::atomic f_ct_ { 0 }; // commit flag
- };
-
- alignas(cache_line_size) std::atomic ct_; // commit index
-
- template
- bool push(W* /*wrapper*/, F&& f, E* elems) {
- circ::u2_t cur_ct, nxt_ct;
- for (unsigned k = 0;;) {
- cur_ct = ct_.load(std::memory_order_relaxed);
- if (circ::index_of(nxt_ct = cur_ct + 1) ==
- circ::index_of(rd_.load(std::memory_order_acquire))) {
- return false; // full
- }
- if (ct_.compare_exchange_weak(cur_ct, nxt_ct, std::memory_order_acq_rel)) {
- break;
- }
- ipc::yield(k);
- }
- auto* el = elems + circ::index_of(cur_ct);
- std::forward(f)(&(el->data_));
- // set flag & try update wt
- el->f_ct_.store(~static_cast(cur_ct), std::memory_order_release);
- while (1) {
- auto cac_ct = el->f_ct_.load(std::memory_order_acquire);
- if (cur_ct != wt_.load(std::memory_order_relaxed)) {
- return true;
- }
- if ((~cac_ct) != cur_ct) {
- return true;
- }
- if (!el->f_ct_.compare_exchange_strong(cac_ct, 0, std::memory_order_relaxed)) {
- return true;
- }
- wt_.store(nxt_ct, std::memory_order_release);
- cur_ct = nxt_ct;
- nxt_ct = cur_ct + 1;
- el = elems + circ::index_of(cur_ct);
- }
- return true;
- }
-
- template
- bool force_push(W* wrapper, F&&, E*) {
- wrapper->elems()->disconnect_receiver(1);
- return false;
- }
-
- template class E, std::size_t DS, std::size_t AS>
- bool pop(W* /*wrapper*/, circ::u2_t& /*cur*/, F&& f, R&& out, E* elems) {
- byte_t buff[DS];
- for (unsigned k = 0;;) {
- auto cur_rd = rd_.load(std::memory_order_relaxed);
- auto cur_wt = wt_.load(std::memory_order_acquire);
- auto id_rd = circ::index_of(cur_rd);
- auto id_wt = circ::index_of(cur_wt);
- if (id_rd == id_wt) {
- auto* el = elems + id_wt;
- auto cac_ct = el->f_ct_.load(std::memory_order_acquire);
- if ((~cac_ct) != cur_wt) {
- return false; // empty
- }
- if (el->f_ct_.compare_exchange_weak(cac_ct, 0, std::memory_order_relaxed)) {
- wt_.store(cur_wt + 1, std::memory_order_release);
- }
- k = 0;
- }
- else {
- std::memcpy(buff, &(elems[circ::index_of(cur_rd)].data_), sizeof(buff));
- if (rd_.compare_exchange_weak(cur_rd, cur_rd + 1, std::memory_order_release)) {
- std::forward(f)(buff);
- std::forward(out)(true);
- return true;
- }
- ipc::yield(k);
- }
- }
- }
-};
-
-template <>
-struct prod_cons_impl> {
-
- using rc_t = std::uint64_t;
-
- enum : rc_t {
- ep_mask = 0x00000000ffffffffull,
- ep_incr = 0x0000000100000000ull
- };
-
- template
- struct elem_t {
- std::aligned_storage_t data_ {};
- std::atomic rc_ { 0 }; // read-counter
- };
-
- alignas(cache_line_size) std::atomic wt_; // write index
- alignas(cache_line_size) rc_t epoch_ { 0 }; // only one writer
-
- circ::u2_t cursor() const noexcept {
- return wt_.load(std::memory_order_acquire);
- }
-
- template
- bool push(W* wrapper, F&& f, E* elems) {
- E* el;
- for (unsigned k = 0;;) {
- circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed);
- if (cc == 0) return false; // no reader
- el = elems + circ::index_of(wt_.load(std::memory_order_relaxed));
- // check all consumers have finished reading this element
- auto cur_rc = el->rc_.load(std::memory_order_acquire);
- circ::cc_t rem_cc = cur_rc & ep_mask;
- if ((cc & rem_cc) && ((cur_rc & ~ep_mask) == epoch_)) {
- return false; // has not finished yet
- }
- // consider rem_cc to be 0 here
- if (el->rc_.compare_exchange_weak(
- cur_rc, epoch_ | static_cast(cc), std::memory_order_release)) {
- break;
- }
- ipc::yield(k);
- }
- std::forward(f)(&(el->data_));
- wt_.fetch_add(1, std::memory_order_release);
- return true;
- }
-
- template
- bool force_push(W* wrapper, F&& f, E* elems) {
- E* el;
- epoch_ += ep_incr;
- for (unsigned k = 0;;) {
- circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed);
- if (cc == 0) return false; // no reader
- el = elems + circ::index_of(wt_.load(std::memory_order_relaxed));
- // check all consumers have finished reading this element
- auto cur_rc = el->rc_.load(std::memory_order_acquire);
- circ::cc_t rem_cc = cur_rc & ep_mask;
- if (cc & rem_cc) {
- ipc::log("force_push: k = %u, cc = %u, rem_cc = %u\n", k, cc, rem_cc);
- cc = wrapper->elems()->disconnect_receiver(rem_cc); // disconnect all invalid readers
- if (cc == 0) return false; // no reader
- }
- // just compare & exchange
- if (el->rc_.compare_exchange_weak(
- cur_rc, epoch_ | static_cast(cc), std::memory_order_release)) {
- break;
- }
- ipc::yield(k);
- }
- std::forward(f)(&(el->data_));
- wt_.fetch_add(1, std::memory_order_release);
- return true;
- }
-
- template
- bool pop(W* wrapper, circ::u2_t& cur, F&& f, R&& out, E* elems) {
- if (cur == cursor()) return false; // acquire
- auto* el = elems + circ::index_of(cur++);
- std::forward(f)(&(el->data_));
- for (unsigned k = 0;;) {
- auto cur_rc = el->rc_.load(std::memory_order_acquire);
- if ((cur_rc & ep_mask) == 0) {
- std::forward(out)(true);
- return true;
- }
- auto nxt_rc = cur_rc & ~static_cast(wrapper->connected_id());
- if (el->rc_.compare_exchange_weak(cur_rc, nxt_rc, std::memory_order_release)) {
- std::forward(out)((nxt_rc & ep_mask) == 0);
- return true;
- }
- ipc::yield(k);
- }
- }
-};
-
-template <>
-struct prod_cons_impl> {
-
- using rc_t = std::uint64_t;
- using flag_t = std::uint64_t;
-
- enum : rc_t {
- rc_mask = 0x00000000ffffffffull,
- ep_mask = 0x00ffffffffffffffull,
- ep_incr = 0x0100000000000000ull,
- ic_mask = 0xff000000ffffffffull,
- ic_incr = 0x0000000100000000ull
- };
-
- template
- struct elem_t {
- std::aligned_storage_t data_ {};
- std::atomic rc_ { 0 }; // read-counter
- std::atomic f_ct_ { 0 }; // commit flag
- };
-
- alignas(cache_line_size) std::atomic ct_; // commit index
- alignas(cache_line_size) std::atomic epoch_ { 0 };
-
- circ::u2_t cursor() const noexcept {
- return ct_.load(std::memory_order_acquire);
- }
-
- constexpr static rc_t inc_rc(rc_t rc) noexcept {
- return (rc & ic_mask) | ((rc + ic_incr) & ~ic_mask);
- }
-
- constexpr static rc_t inc_mask(rc_t rc) noexcept {
- return inc_rc(rc) & ~rc_mask;
- }
-
- template
- bool push(W* wrapper, F&& f, E* elems) {
- E* el;
- circ::u2_t cur_ct;
- rc_t epoch = epoch_.load(std::memory_order_acquire);
- for (unsigned k = 0;;) {
- circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed);
- if (cc == 0) return false; // no reader
- el = elems + circ::index_of(cur_ct = ct_.load(std::memory_order_relaxed));
- // check all consumers have finished reading this element
- auto cur_rc = el->rc_.load(std::memory_order_relaxed);
- circ::cc_t rem_cc = cur_rc & rc_mask;
- if ((cc & rem_cc) && ((cur_rc & ~ep_mask) == epoch)) {
- return false; // has not finished yet
- }
- else if (!rem_cc) {
- auto cur_fl = el->f_ct_.load(std::memory_order_acquire);
- if ((cur_fl != cur_ct) && cur_fl) {
- return false; // full
- }
- }
- // consider rem_cc to be 0 here
- if (el->rc_.compare_exchange_weak(
- cur_rc, inc_mask(epoch | (cur_rc & ep_mask)) | static_cast(cc), std::memory_order_relaxed) &&
- epoch_.compare_exchange_weak(epoch, epoch, std::memory_order_acq_rel)) {
- break;
- }
- ipc::yield(k);
- }
- // only one thread/process would touch here at one time
- ct_.store(cur_ct + 1, std::memory_order_release);
- std::forward(f)(&(el->data_));
- // set flag & try update wt
- el->f_ct_.store(~static_cast(cur_ct), std::memory_order_release);
- return true;
- }
-
- template
- bool force_push(W* wrapper, F&& f, E* elems) {
- E* el;
- circ::u2_t cur_ct;
- rc_t epoch = epoch_.fetch_add(ep_incr, std::memory_order_release) + ep_incr;
- for (unsigned k = 0;;) {
- circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed);
- if (cc == 0) return false; // no reader
- el = elems + circ::index_of(cur_ct = ct_.load(std::memory_order_relaxed));
- // check all consumers have finished reading this element
- auto cur_rc = el->rc_.load(std::memory_order_acquire);
- circ::cc_t rem_cc = cur_rc & rc_mask;
- if (cc & rem_cc) {
- ipc::log("force_push: k = %u, cc = %u, rem_cc = %u\n", k, cc, rem_cc);
- cc = wrapper->elems()->disconnect_receiver(rem_cc); // disconnect all invalid readers
- if (cc == 0) return false; // no reader
- }
- // just compare & exchange
- if (el->rc_.compare_exchange_weak(
- cur_rc, inc_mask(epoch | (cur_rc & ep_mask)) | static_cast(cc), std::memory_order_relaxed)) {
- if (epoch == epoch_.load(std::memory_order_acquire)) {
- break;
- }
- else if (push(wrapper, std::forward(f), elems)) {
- return true;
- }
- epoch = epoch_.fetch_add(ep_incr, std::memory_order_release) + ep_incr;
- }
- ipc::yield(k);
- }
- // only one thread/process would touch here at one time
- ct_.store(cur_ct + 1, std::memory_order_release);
- std::forward(f)(&(el->data_));
- // set flag & try update wt
- el->f_ct_.store(~static_cast(cur_ct), std::memory_order_release);
- return true;
- }
-
- template
- bool pop(W* wrapper, circ::u2_t& cur, F&& f, R&& out, E(& elems)[N]) {
- auto* el = elems + circ::index_of(cur);
- auto cur_fl = el->f_ct_.load(std::memory_order_acquire);
- if (cur_fl != ~static_cast(cur)) {
- return false; // empty
- }
- ++cur;
- std::forward(f)(&(el->data_));
- for (unsigned k = 0;;) {
- auto cur_rc = el->rc_.load(std::memory_order_acquire);
- if ((cur_rc & rc_mask) == 0) {
- std::forward(out)(true);
- el->f_ct_.store(cur + N - 1, std::memory_order_release);
- return true;
- }
- auto nxt_rc = inc_rc(cur_rc) & ~static_cast(wrapper->connected_id());
- bool last_one = false;
- if ((last_one = (nxt_rc & rc_mask) == 0)) {
- el->f_ct_.store(cur + N - 1, std::memory_order_release);
- }
- if (el->rc_.compare_exchange_weak(cur_rc, nxt_rc, std::memory_order_release)) {
- std::forward(out)(last_one);
- return true;
- }
- ipc::yield(k);
- }
- }
-};
-
-} // namespace ipc
diff --git a/spaces/haoheliu/AudioLDM_48K_Text-to-HiFiAudio_Generation/app.py b/spaces/haoheliu/AudioLDM_48K_Text-to-HiFiAudio_Generation/app.py
deleted file mode 100644
index a5cd6b4fd73be2bb1a170f6e2ce753c170d52cad..0000000000000000000000000000000000000000
--- a/spaces/haoheliu/AudioLDM_48K_Text-to-HiFiAudio_Generation/app.py
+++ /dev/null
@@ -1,358 +0,0 @@
-from sys import maxsize
-from huggingface_hub import hf_hub_download
-import torch
-import os
-
-import gradio as gr
-from audioldm2 import text_to_audio, build_model
-from share_btn import community_icon_html, loading_icon_html, share_js
-
-os.environ["TOKENIZERS_PARALLELISM"] = "true"
-
-# default_checkpoint="audioldm2-full"
-default_checkpoint="audioldm_48k"
-audioldm = None
-current_model_name = None
-
-def text2audio(
- text,
- duration,
- guidance_scale,
- random_seed,
- n_candidates,
- model_name=default_checkpoint,
-):
- global audioldm, current_model_name
- torch.set_float32_matmul_precision("high")
-
- if audioldm is None or model_name != current_model_name:
- audioldm = build_model(model_name=model_name)
- current_model_name = model_name
- # audioldm = torch.compile(audioldm)
- # print(text, length, guidance_scale)
- if("48k" in model_name):
- latent_t_per_second=12.8
- sample_rate=48000
- else:
- latent_t_per_second=25.6
- sample_rate=16000
-
- waveform = text_to_audio(
- latent_diffusion=audioldm,
- text=text,
- seed=random_seed,
- duration=duration,
- guidance_scale=guidance_scale,
- n_candidate_gen_per_text=int(n_candidates),
- latent_t_per_second=latent_t_per_second,
- ) # [bs, 1, samples]
- waveform = [
- gr.make_waveform((sample_rate, wave[0]), bg_image="bg.png") for wave in waveform
- ]
- # waveform = [(16000, np.random.randn(16000)), (16000, np.random.randn(16000))]
- if len(waveform) == 1:
- waveform = waveform[0]
- return waveform
-
-text2audio("Birds singing sweetly in a blooming garden.", 10, 3.5, 45, 3, default_checkpoint)
-
-css = """
- a {
- color: inherit;
- text-decoration: underline;
- }
- .gradio-container {
- font-family: 'IBM Plex Sans', sans-serif;
- }
- .gr-button {
- color: white;
- border-color: #000000;
- background: #000000;
- }
- input[type='range'] {
- accent-color: #000000;
- }
- .dark input[type='range'] {
- accent-color: #dfdfdf;
- }
- .container {
- max-width: 730px;
- margin: auto;
- padding-top: 1.5rem;
- }
- #gallery {
- min-height: 22rem;
- margin-bottom: 15px;
- margin-left: auto;
- margin-right: auto;
- border-bottom-right-radius: .5rem !important;
- border-bottom-left-radius: .5rem !important;
- }
- #gallery>div>.h-full {
- min-height: 20rem;
- }
- .details:hover {
- text-decoration: underline;
- }
- .gr-button {
- white-space: nowrap;
- }
- .gr-button:focus {
- border-color: rgb(147 197 253 / var(--tw-border-opacity));
- outline: none;
- box-shadow: var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow, 0 0 #0000);
- --tw-border-opacity: 1;
- --tw-ring-offset-shadow: var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color);
- --tw-ring-shadow: var(--tw-ring-inset) 0 0 0 calc(3px var(--tw-ring-offset-width)) var(--tw-ring-color);
- --tw-ring-color: rgb(191 219 254 / var(--tw-ring-opacity));
- --tw-ring-opacity: .5;
- }
- #advanced-btn {
- font-size: .7rem !important;
- line-height: 19px;
- margin-top: 12px;
- margin-bottom: 12px;
- padding: 2px 8px;
- border-radius: 14px !important;
- }
- #advanced-options {
- margin-bottom: 20px;
- }
- .footer {
- margin-bottom: 45px;
- margin-top: 35px;
- text-align: center;
- border-bottom: 1px solid #e5e5e5;
- }
- .footer>p {
- font-size: .8rem;
- display: inline-block;
- padding: 0 10px;
- transform: translateY(10px);
- background: white;
- }
- .dark .footer {
- border-color: #303030;
- }
- .dark .footer>p {
- background: #0b0f19;
- }
- .acknowledgments h4{
- margin: 1.25em 0 .25em 0;
- font-weight: bold;
- font-size: 115%;
- }
- #container-advanced-btns{
- display: flex;
- flex-wrap: wrap;
- justify-content: space-between;
- align-items: center;
- }
- .animate-spin {
- animation: spin 1s linear infinite;
- }
- @keyframes spin {
- from {
- transform: rotate(0deg);
- }
- to {
- transform: rotate(360deg);
- }
- }
- #share-btn-container {
- display: flex; padding-left: 0.5rem !important; padding-right: 0.5rem !important; background-color: #000000; justify-content: center; align-items: center; border-radius: 9999px !important; width: 13rem;
- margin-top: 10px;
- margin-left: auto;
- }
- #share-btn {
- all: initial; color: #ffffff;font-weight: 600; cursor:pointer; font-family: 'IBM Plex Sans', sans-serif; margin-left: 0.5rem !important; padding-top: 0.25rem !important; padding-bottom: 0.25rem !important;right:0;
- }
- #share-btn * {
- all: unset;
- }
- #share-btn-container div:nth-child(-n+2){
- width: auto !important;
- min-height: 0px !important;
- }
- #share-btn-container .wrap {
- display: none !important;
- }
- .gr-form{
- flex: 1 1 50%; border-top-right-radius: 0; border-bottom-right-radius: 0;
- }
- #prompt-container{
- gap: 0;
- }
- #generated_id{
- min-height: 700px
- }
- #setting_id{
- margin-bottom: 12px;
- text-align: center;
- font-weight: 900;
- }
-"""
-iface = gr.Blocks(css=css)
-
-with iface:
- gr.HTML(
- """
-
-
-
- 48kHz AudioLDM: Generating High-Fidelity Audio and Music with Text
-
-
-
-
- """
- )
- gr.HTML(
- """
- For faster inference without waiting in queue, you may duplicate the space and upgrade to GPU in settings.
-
-
-
-
- """
- )
- with gr.Group():
- with gr.Box():
- ############# Input
- textbox = gr.Textbox(
- value="A forest of wind chimes singing a soothing melody in the breeze.",
- max_lines=1,
- label="Input your text here. If the output is not good enough, switching to a different seed will help.",
- elem_id="prompt-in",
- )
-
- with gr.Accordion("Click to modify detailed configurations", open=False):
- seed = gr.Number(
- value=45,
- label="Change this value (any integer number) will lead to a different generation result.",
- )
- duration = gr.Slider(
- 5, 15, value=10, step=2.5, label="Duration (seconds)"
- )
- guidance_scale = gr.Slider(
- 0,
- 6,
- value=3.5,
- step=0.5,
- label="Guidance scale (Large => better quality and relavancy to text; Small => better diversity)",
- )
- n_candidates = gr.Slider(
- 1,
- 3,
- value=3,
- step=1,
- label="Automatic quality control. This number control the number of candidates (e.g., generate three audios and choose the best to show you). A Larger value usually lead to better quality with heavier computation",
- )
- model_name = gr.Dropdown(
- ["audioldm_48k", "audioldm_crossattn_flant5", "audioldm2-full"], value="audioldm_48k",
- )
- ############# Output
- # outputs=gr.Audio(label="Output", type="numpy")
- outputs = gr.Video(label="Output", elem_id="output-video")
-
- # with gr.Group(elem_id="container-advanced-btns"):
- # # advanced_button = gr.Button("Advanced options", elem_id="advanced-btn")
- # with gr.Group(elem_id="share-btn-container"):
- # community_icon = gr.HTML(community_icon_html, visible=False)
- # loading_icon = gr.HTML(loading_icon_html, visible=False)
- # share_button = gr.Button("Share to community", elem_id="share-btn", visible=False)
- # outputs=[gr.Audio(label="Output", type="numpy"), gr.Audio(label="Output", type="numpy")]
- btn = gr.Button("Submit").style(full_width=True)
-
- with gr.Group(elem_id="share-btn-container", visible=False):
- community_icon = gr.HTML(community_icon_html)
- loading_icon = gr.HTML(loading_icon_html)
- share_button = gr.Button("Share to community", elem_id="share-btn")
-
- # btn.click(text2audio, inputs=[
- # textbox, duration, guidance_scale, seed, n_candidates, model_name], outputs=[outputs])
- btn.click(
- text2audio,
- inputs=[textbox, duration, guidance_scale, seed, n_candidates],
- outputs=[outputs],
- api_name="text2audio",
- )
-
- share_button.click(None, [], [], _js=share_js)
- gr.HTML(
- """
-
- """
- )
- gr.Examples(
- [
- [
- "Birds singing sweetly in a blooming garden.",
- 10,
- 3.5,
- 45,
- 3,
- default_checkpoint,
- ],
- [
- "A modern synthesizer creating futuristic soundscapes.",
- 10,
- 3.5,
- 45,
- 3,
- default_checkpoint,
- ],
- [
- "The vibrant beat of Brazilian samba drums.",
- 10,
- 3.5,
- 45,
- 3,
- default_checkpoint,
- ],
- ],
- fn=text2audio,
- inputs=[textbox, duration, guidance_scale, seed, n_candidates, model_name],
- # inputs=[textbox, guidance_scale, seed, n_candidates],
- outputs=[outputs],
- cache_examples=True,
- )
- gr.HTML(
- """
-
- Essential Tricks for Enhancing the Quality of Your Generated Audio
- 1. Try to use more adjectives to describe your sound. For example: "A man is speaking clearly and slowly in a large room" is better than "A man is speaking". This can make sure AudioLDM 2 understands what you want.
- 2. Try to use different random seeds, which can affect the generation quality significantly sometimes.
- 3. It's better to use general terms like 'man' or 'woman' instead of specific names for individuals or abstract objects that humans may not be familiar with, such as 'mummy'.
-
- """
- )
-
- with gr.Accordion("Additional information", open=False):
- gr.HTML(
- """
-
- We build the model with data from AudioSet, Freesound and BBC Sound Effect library. We share this demo based on the UK copyright exception of data for academic research.
-
- """
- )
-# This demo is strictly for research demo purpose only. For commercial use please contact us.
-
-iface.queue(max_size=20)
-iface.launch(debug=True)
-# iface.launch(debug=True, share=True)
diff --git a/spaces/harshvardhansb/ObjectDetection/public/index.html b/spaces/harshvardhansb/ObjectDetection/public/index.html
deleted file mode 100644
index a8c1d6b197c9b7c0b7fef67e0ac7f071ca028933..0000000000000000000000000000000000000000
--- a/spaces/harshvardhansb/ObjectDetection/public/index.html
+++ /dev/null
@@ -1,23 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
- Object Detection
-
-
-
-
-
-
-
diff --git a/spaces/hasibzunair/fifa-tryon-demo/Self-Correction-Human-Parsing-for-ACGPN/mhp_extension/detectron2/projects/DensePose/tests/test_setup.py b/spaces/hasibzunair/fifa-tryon-demo/Self-Correction-Human-Parsing-for-ACGPN/mhp_extension/detectron2/projects/DensePose/tests/test_setup.py
deleted file mode 100644
index 96827f14b3a71d571c2109791233b5bcf7ef35f8..0000000000000000000000000000000000000000
--- a/spaces/hasibzunair/fifa-tryon-demo/Self-Correction-Human-Parsing-for-ACGPN/mhp_extension/detectron2/projects/DensePose/tests/test_setup.py
+++ /dev/null
@@ -1,30 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-
-import unittest
-
-from .common import (
- get_config_files,
- get_evolution_config_files,
- get_quick_schedules_config_files,
- setup,
-)
-
-
-class TestSetup(unittest.TestCase):
- def _test_setup(self, config_file):
- setup(config_file)
-
- def test_setup_configs(self):
- config_files = get_config_files()
- for config_file in config_files:
- self._test_setup(config_file)
-
- def test_setup_evolution_configs(self):
- config_files = get_evolution_config_files()
- for config_file in config_files:
- self._test_setup(config_file)
-
- def test_setup_quick_schedules_configs(self):
- config_files = get_quick_schedules_config_files()
- for config_file in config_files:
- self._test_setup(config_file)
diff --git a/spaces/hf4h/bio-chem-foundation-models/model_list.py b/spaces/hf4h/bio-chem-foundation-models/model_list.py
deleted file mode 100644
index 886991b59a1049d2cfbd3ba35a54966480c4ee71..0000000000000000000000000000000000000000
--- a/spaces/hf4h/bio-chem-foundation-models/model_list.py
+++ /dev/null
@@ -1,106 +0,0 @@
-from __future__ import annotations
-
-import numpy as np
-import pandas as pd
-import requests
-from huggingface_hub.hf_api import SpaceInfo
-
-url = 'https://docs.google.com/spreadsheets/d/1XH7Jo3LXXfbSJ14z-QrSIQs21ArJMiV6_hMSAwY85PU/edit#gid=0'
-csv_url = url.replace('/edit#gid=', '/export?format=csv&gid=')
-
-class ModelList:
- def __init__(self):
- self.table = pd.read_csv(csv_url)
- self._preprocess_table()
-
- self.table_header = '''
-
- Model Name
- Type
- Year
- Paper
- Code on Github
- Weights on 🤗
- Other Weights
- '''
-
- def _preprocess_table(self) -> None:
- self.table['name_lowercase'] = self.table.name.str.lower()
- self.table['year'] = self.table['year'].apply(str)
-
- rows = []
- for row in self.table.itertuples():
- paper = f'Paper' if isinstance(
- row.paper, str) else ''
- github = f'GitHub' if isinstance(
- row.github, str) else ''
- hf_model = f'Hub Model' if isinstance(
- row.hub, str) else ''
- other_model = f'Other Weights' if isinstance(
- row.other, str) else ''
- data_type = f'{row.data_type}' if isinstance(
- row.data_type, str) else ''
- base_model = f'{row.base_model}' if isinstance(
- row.base_model, str) else ''
- year = f'{row.year}' if isinstance(
- row.year, str) else ''
- row = f'''
-
- {row.name}
- {data_type}
- {year}
- {paper}
- {github}
- {hf_model}
- {other_model}
- '''
- rows.append(row)
- self.table['html_table_content'] = rows
-
- def render(self, search_query: str,
- case_sensitive: bool,
- filter_names: list[str],
- data_types: list[str],
- years: list[str],
- #model_types: list[str]
- ) -> tuple[int, str]:
- df = self.table
- if search_query:
- if case_sensitive:
- df = df[df.name.str.contains(search_query)]
- else:
- df = df[df.name_lowercase.str.contains(search_query.lower())]
- has_paper = 'Paper' in filter_names
- has_github = 'Code' in filter_names
- has_model = 'Model Weights' in filter_names
- df = self.filter_table(df, has_paper, has_github, has_model, data_types, years)
- #df = self.filter_table(df, has_paper, has_github, has_model, data_types, model_types)
- return len(df), self.to_html(df, self.table_header)
-
- @staticmethod
- def filter_table(df: pd.DataFrame, has_paper: bool, has_github: bool,
- has_model: bool,
- data_types: list[str],
- years: list[str],
- #model_types: list[str]
- ) -> pd.DataFrame:
- if has_paper:
- df = df[~df.paper.isna()]
- if has_github:
- df = df[~df.github.isna()]
- if has_model:
- df = df[~df.hub.isna() | ~df.other.isna()]
- df = df[df.data_type.isin(set(data_types))]
- #df = df[df.base_model.isin(set(model_types))]
- df = df[df.year.isin(set(years))]
- return df
-
- @staticmethod
- def to_html(df: pd.DataFrame, table_header: str) -> str:
- table_data = ''.join(df.html_table_content)
- html = f'''
-
- {table_header}
- {table_data}
-
'''
- return html
\ No newline at end of file
diff --git a/spaces/hylee/photo2cartoon/p2c/utils/face_seg.py b/spaces/hylee/photo2cartoon/p2c/utils/face_seg.py
deleted file mode 100644
index 4938ccebbb7e55f959889c1bf3bc2ca7dac7ffe6..0000000000000000000000000000000000000000
--- a/spaces/hylee/photo2cartoon/p2c/utils/face_seg.py
+++ /dev/null
@@ -1,44 +0,0 @@
-import os
-import cv2
-import numpy as np
-import tensorflow as tf
-from tensorflow.python.platform import gfile
-
-
-curPath = os.path.abspath(os.path.dirname(__file__))
-
-
-class FaceSeg:
- def __init__(self, model_path=os.path.join(curPath, 'seg_model_384.pb')):
- config = tf.compat.v1.ConfigProto()
- config.gpu_options.allow_growth = True
- self._graph = tf.Graph()
- self._sess = tf.compat.v1.Session(config=config, graph=self._graph)
-
- self.pb_file_path = model_path
- self._restore_from_pb()
- self.input_op = self._sess.graph.get_tensor_by_name('input_1:0')
- self.output_op = self._sess.graph.get_tensor_by_name('sigmoid/Sigmoid:0')
-
- def _restore_from_pb(self):
- with self._sess.as_default():
- with self._graph.as_default():
- with gfile.FastGFile(self.pb_file_path, 'rb') as f:
- graph_def = tf.compat.v1.GraphDef()
- graph_def.ParseFromString(f.read())
- tf.import_graph_def(graph_def, name='')
-
- def input_transform(self, image):
- image = cv2.resize(image, (384, 384), interpolation=cv2.INTER_AREA)
- image_input = (image / 255.)[np.newaxis, :, :, :]
- return image_input
-
- def output_transform(self, output, shape):
- output = cv2.resize(output, (shape[1], shape[0]))
- image_output = (output * 255).astype(np.uint8)
- return image_output
-
- def get_mask(self, image):
- image_input = self.input_transform(image)
- output = self._sess.run(self.output_op, feed_dict={self.input_op: image_input})[0]
- return self.output_transform(output, shape=image.shape[:2])
diff --git a/spaces/hyxue/HiFiFace-inference-demo/Deep3DFaceRecon_pytorch/data/image_folder.py b/spaces/hyxue/HiFiFace-inference-demo/Deep3DFaceRecon_pytorch/data/image_folder.py
deleted file mode 100644
index 0a02dfe06948ddb90a76667d538f7e3ea47a33e8..0000000000000000000000000000000000000000
--- a/spaces/hyxue/HiFiFace-inference-demo/Deep3DFaceRecon_pytorch/data/image_folder.py
+++ /dev/null
@@ -1,77 +0,0 @@
-"""A modified image folder class
-
-We modify the official PyTorch image folder (https://github.com/pytorch/vision/blob/master/torchvision/datasets/folder.py)
-so that this class can load images from both current directory and its subdirectories.
-"""
-import os.path
-
-import numpy as np
-import torch.utils.data as data
-from PIL import Image
-
-IMG_EXTENSIONS = [
- ".jpg",
- ".JPG",
- ".jpeg",
- ".JPEG",
- ".png",
- ".PNG",
- ".ppm",
- ".PPM",
- ".bmp",
- ".BMP",
- ".tif",
- ".TIF",
- ".tiff",
- ".TIFF",
-]
-
-
-def is_image_file(filename):
- return any(filename.endswith(extension) for extension in IMG_EXTENSIONS)
-
-
-def make_dataset(dir, max_dataset_size=float("inf")):
- images = []
- assert os.path.isdir(dir) or os.path.islink(dir), "%s is not a valid directory" % dir
-
- for root, _, fnames in sorted(os.walk(dir, followlinks=True)):
- for fname in fnames:
- if is_image_file(fname):
- path = os.path.join(root, fname)
- images.append(path)
- return images[: min(max_dataset_size, len(images))]
-
-
-def default_loader(path):
- return Image.open(path).convert("RGB")
-
-
-class ImageFolder(data.Dataset):
- def __init__(self, root, transform=None, return_paths=False, loader=default_loader):
- imgs = make_dataset(root)
- if len(imgs) == 0:
- raise (
- RuntimeError(
- "Found 0 images in: " + root + "\n" "Supported image extensions are: " + ",".join(IMG_EXTENSIONS)
- )
- )
-
- self.root = root
- self.imgs = imgs
- self.transform = transform
- self.return_paths = return_paths
- self.loader = loader
-
- def __getitem__(self, index):
- path = self.imgs[index]
- img = self.loader(path)
- if self.transform is not None:
- img = self.transform(img)
- if self.return_paths:
- return img, path
- else:
- return img
-
- def __len__(self):
- return len(self.imgs)
diff --git a/spaces/ibvhim/Gradio-Apps/Chatbot/app.py b/spaces/ibvhim/Gradio-Apps/Chatbot/app.py
deleted file mode 100644
index 98ab8f8bb570d27ff5890317bd431fe00a1379c1..0000000000000000000000000000000000000000
--- a/spaces/ibvhim/Gradio-Apps/Chatbot/app.py
+++ /dev/null
@@ -1,35 +0,0 @@
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
-
-tokenizer = AutoTokenizer.from_pretrained("microsoft/DialoGPT-medium")
-model = AutoModelForCausalLM.from_pretrained("microsoft/DialoGPT-medium")
-
-
-def predict(input, history=[]):
- # tokenize the new input sentence
- new_user_input_ids = tokenizer.encode(input + tokenizer.eos_token, return_tensors='pt')
-
- # append the new user input tokens to the chat history
- bot_input_ids = torch.cat([torch.LongTensor(history), new_user_input_ids], dim=-1)
-
- # generate a response
- history = model.generate(bot_input_ids, max_length=1000, pad_token_id=tokenizer.eos_token_id).tolist()
-
- # convert the tokens to text, and then split the responses into the right format
- response = tokenizer.decode(history[0]).split("<|endoftext|>")
- response = [(response[i], response[i + 1]) for i in range(0, len(response) - 1, 2)] # convert to tuples of list
- return response, history
-
-
-import gradio as gr
-
-interface = gr.Interface(
- fn=predict,
- theme="default",
- css=".footer {display:none !important}",
- inputs=["text", "state"],
- outputs=["chatbot", "state"],
-)
-
-if __name__ == '__main__':
- interface.launch()
diff --git a/spaces/imperialwool/funapi/templates/forbidden.html b/spaces/imperialwool/funapi/templates/forbidden.html
deleted file mode 100644
index 3d48e67e9ae17434267c83438d3d2cb491779787..0000000000000000000000000000000000000000
--- a/spaces/imperialwool/funapi/templates/forbidden.html
+++ /dev/null
@@ -1,3 +0,0 @@
-403 Forbidden
-
-403
Forbidden
\ No newline at end of file
diff --git a/spaces/inamXcontru/PoeticTTS/Delcam PowerMill 2013 Download Learn How to Use PowerMill for CNC Machining and CAM.md b/spaces/inamXcontru/PoeticTTS/Delcam PowerMill 2013 Download Learn How to Use PowerMill for CNC Machining and CAM.md
deleted file mode 100644
index 0a41799a7b57af4460c527bed6549982252299b8..0000000000000000000000000000000000000000
--- a/spaces/inamXcontru/PoeticTTS/Delcam PowerMill 2013 Download Learn How to Use PowerMill for CNC Machining and CAM.md
+++ /dev/null
@@ -1,6 +0,0 @@
-delcampowermill2013download
DOWNLOAD 🆓 https://gohhs.com/2uz46t
-
- aaccfb2cb3
-
-
-
diff --git a/spaces/innnky/nyaru-svc2.0/data_utils.py b/spaces/innnky/nyaru-svc2.0/data_utils.py
deleted file mode 100644
index e125a0637908e1284208b80e4b16a50996a136be..0000000000000000000000000000000000000000
--- a/spaces/innnky/nyaru-svc2.0/data_utils.py
+++ /dev/null
@@ -1,413 +0,0 @@
-import time
-import os
-import random
-import numpy as np
-import torch
-import torch.utils.data
-import numpy as np
-import commons
-from mel_processing import spectrogram_torch
-from utils import load_wav_to_torch, load_filepaths_and_text
-from text import text_to_sequence, cleaned_text_to_sequence
-
-
-def dropout1d(myarray, ratio=0.5):
- indices = np.random.choice(np.arange(myarray.size), replace=False,
- size=int(myarray.size * ratio))
- myarray[indices] = 0
- return myarray
-
-
-class TextAudioLoader(torch.utils.data.Dataset):
- """
- 1) loads audio, text pairs
- 2) normalizes text and converts them to sequences of integers
- 3) computes spectrograms from audio files.
- """
-
- def __init__(self, audiopaths_and_text, hparams):
- self.audiopaths_and_text = load_filepaths_and_text(audiopaths_and_text)
- self.text_cleaners = hparams.text_cleaners
- self.max_wav_value = hparams.max_wav_value
- self.sampling_rate = hparams.sampling_rate
- self.filter_length = hparams.filter_length
- self.hop_length = hparams.hop_length
- self.win_length = hparams.win_length
- self.sampling_rate = hparams.sampling_rate
-
- self.cleaned_text = getattr(hparams, "cleaned_text", False)
-
- self.add_blank = hparams.add_blank
- self.min_text_len = getattr(hparams, "min_text_len", 1)
- self.max_text_len = getattr(hparams, "max_text_len", 190)
-
- random.seed(1234)
- random.shuffle(self.audiopaths_and_text)
- self._filter()
-
- def _filter(self):
- """
- Filter text & store spec lengths
- """
- # Store spectrogram lengths for Bucketing
- # wav_length ~= file_size / (wav_channels * Bytes per dim) = file_size / (1 * 2)
- # spec_length = wav_length // hop_length
- lengths = []
- for audiopath, text, pitch in self.audiopaths_and_text:
- lengths.append(os.path.getsize(audiopath) // (2 * self.hop_length))
- self.lengths = lengths
-
- def get_audio_text_pair(self, audiopath_and_text):
- # separate filename and text
- audiopath, text, pitch = audiopath_and_text[0], audiopath_and_text[1],audiopath_and_text[2]
- text = self.get_text(text)
- spec, wav = self.get_audio(audiopath)
- pitch = self.get_pitch(pitch)
- return (text, spec, wav, pitch)
-
- def get_pitch(self, pitch):
-
- return torch.LongTensor(np.load(pitch))
-
- def get_audio(self, filename):
- audio, sampling_rate = load_wav_to_torch(filename)
- if sampling_rate != self.sampling_rate:
- raise ValueError("{} {} SR doesn't match target {} SR".format(
- sampling_rate, self.sampling_rate))
- audio_norm = audio / self.max_wav_value
- audio_norm = audio_norm.unsqueeze(0)
- spec_filename = filename.replace(".wav", ".spec.pt")
- if os.path.exists(spec_filename):
- spec = torch.load(spec_filename)
- else:
- spec = spectrogram_torch(audio_norm, self.filter_length,
- self.sampling_rate, self.hop_length, self.win_length,
- center=False)
- spec = torch.squeeze(spec, 0)
- torch.save(spec, spec_filename)
- return spec, audio_norm
-
- def get_text(self, text):
- soft = np.load(text)
- text_norm = torch.FloatTensor(soft)
- return text_norm
-
- def __getitem__(self, index):
- return self.get_audio_text_pair(self.audiopaths_and_text[index])
-
- def __len__(self):
- return len(self.audiopaths_and_text)
-
-
-class TextAudioCollate():
- """ Zero-pads model inputs and targets
- """
-
- def __init__(self, return_ids=False):
- self.return_ids = return_ids
-
- def __call__(self, batch):
- """Collate's training batch from normalized text and aduio
- PARAMS
- ------
- batch: [text_normalized, spec_normalized, wav_normalized]
- """
- # Right zero-pad all one-hot text sequences to max input length
- _, ids_sorted_decreasing = torch.sort(
- torch.LongTensor([x[1].size(1) for x in batch]),
- dim=0, descending=True)
-
- max_text_len = max([len(x[0]) for x in batch])
- max_spec_len = max([x[1].size(1) for x in batch])
- max_wav_len = max([x[2].size(1) for x in batch])
- max_pitch_len = max([x[3].shape[0] for x in batch])
- # print(batch)
-
-
- text_lengths = torch.LongTensor(len(batch))
- spec_lengths = torch.LongTensor(len(batch))
- wav_lengths = torch.LongTensor(len(batch))
-
- text_padded = torch.FloatTensor(len(batch), max_text_len, 256)
- spec_padded = torch.FloatTensor(len(batch), batch[0][1].size(0), max_spec_len)
- wav_padded = torch.FloatTensor(len(batch), 1, max_wav_len)
- pitch_padded = torch.LongTensor(len(batch), max_pitch_len)
-
- text_padded.zero_()
- spec_padded.zero_()
- wav_padded.zero_()
- pitch_padded.zero_()
- for i in range(len(ids_sorted_decreasing)):
- row = batch[ids_sorted_decreasing[i]]
-
- text = row[0]
- text_padded[i, :text.size(0), :] = text
- text_lengths[i] = text.size(0)
-
- spec = row[1]
- spec_padded[i, :, :spec.size(1)] = spec
- spec_lengths[i] = spec.size(1)
-
- wav = row[2]
- wav_padded[i, :, :wav.size(1)] = wav
- wav_lengths[i] = wav.size(1)
-
- pitch = row[3]
- pitch_padded[i, :pitch.size(0)] = pitch
-
- if self.return_ids:
- return text_padded, text_lengths, spec_padded, spec_lengths, wav_padded, wav_lengths, ids_sorted_decreasing, pitch_padded
- return text_padded, text_lengths, spec_padded, spec_lengths, wav_padded, wav_lengths, pitch_padded
-
-
-"""Multi speaker version"""
-
-
-class TextAudioSpeakerLoader(torch.utils.data.Dataset):
- """
- 1) loads audio, speaker_id, text pairs
- 2) normalizes text and converts them to sequences of integers
- 3) computes spectrograms from audio files.
- """
-
- def __init__(self, audiopaths_sid_text, hparams):
- self.audiopaths_sid_text = load_filepaths_and_text(audiopaths_sid_text)
- self.text_cleaners = hparams.text_cleaners
- self.max_wav_value = hparams.max_wav_value
- self.sampling_rate = hparams.sampling_rate
- self.filter_length = hparams.filter_length
- self.hop_length = hparams.hop_length
- self.win_length = hparams.win_length
- self.sampling_rate = hparams.sampling_rate
-
- self.cleaned_text = getattr(hparams, "cleaned_text", False)
-
- self.add_blank = hparams.add_blank
- self.min_text_len = getattr(hparams, "min_text_len", 1)
- self.max_text_len = getattr(hparams, "max_text_len", 190)
-
- random.seed(1234)
- random.shuffle(self.audiopaths_sid_text)
- self._filter()
-
- def _filter(self):
- """
- Filter text & store spec lengths
- """
- # Store spectrogram lengths for Bucketing
- # wav_length ~= file_size / (wav_channels * Bytes per dim) = file_size / (1 * 2)
- # spec_length = wav_length // hop_length
-
- lengths = []
- for audiopath, sid, text, pitch in self.audiopaths_sid_text:
- lengths.append(os.path.getsize(audiopath) // (2 * self.hop_length))
- self.lengths = lengths
-
- def get_audio_text_speaker_pair(self, audiopath_sid_text):
- # separate filename, speaker_id and text
- audiopath, sid, text, pitch = audiopath_sid_text[0], audiopath_sid_text[1], audiopath_sid_text[2], audiopath_sid_text[3]
- text = self.get_text(text)
- spec, wav = self.get_audio(audiopath)
- sid = self.get_sid(sid)
- pitch = self.get_pitch(pitch)
-
- return (text, spec, wav, pitch, sid)
-
- def get_audio(self, filename):
- audio, sampling_rate = load_wav_to_torch(filename)
- if sampling_rate != self.sampling_rate:
- raise ValueError("{} {} SR doesn't match target {} SR".format(
- sampling_rate, self.sampling_rate))
- audio_norm = audio / self.max_wav_value
- audio_norm = audio_norm.unsqueeze(0)
- spec_filename = filename.replace(".wav", ".spec.pt")
- if os.path.exists(spec_filename):
- spec = torch.load(spec_filename)
- else:
- spec = spectrogram_torch(audio_norm, self.filter_length,
- self.sampling_rate, self.hop_length, self.win_length,
- center=False)
- spec = torch.squeeze(spec, 0)
- torch.save(spec, spec_filename)
- return spec, audio_norm
-
- def get_text(self, text):
- soft = np.load(text)
- text_norm = torch.FloatTensor(soft)
- return text_norm
-
- def get_pitch(self, pitch):
- return torch.LongTensor(np.load(pitch))
-
- def get_sid(self, sid):
- sid = torch.LongTensor([int(sid)])
- return sid
-
- def __getitem__(self, index):
- return self.get_audio_text_speaker_pair(self.audiopaths_sid_text[index])
-
- def __len__(self):
- return len(self.audiopaths_sid_text)
-
-
-class TextAudioSpeakerCollate():
- """ Zero-pads model inputs and targets
- """
-
- def __init__(self, return_ids=False):
- self.return_ids = return_ids
-
- def __call__(self, batch):
- """Collate's training batch from normalized text, audio and speaker identities
- PARAMS
- ------
- batch: [text_normalized, spec_normalized, wav_normalized, sid]
- """
- # Right zero-pad all one-hot text sequences to max input length
- _, ids_sorted_decreasing = torch.sort(
- torch.LongTensor([x[1].size(1) for x in batch]),
- dim=0, descending=True)
-
- max_text_len = max([len(x[0]) for x in batch])
- max_spec_len = max([x[1].size(1) for x in batch])
- max_wav_len = max([x[2].size(1) for x in batch])
- max_pitch_len = max([x[3].shape[0] for x in batch])
-
- text_lengths = torch.LongTensor(len(batch))
- spec_lengths = torch.LongTensor(len(batch))
- wav_lengths = torch.LongTensor(len(batch))
- sid = torch.LongTensor(len(batch))
-
- text_padded = torch.FloatTensor(len(batch), max_text_len, 256)
- spec_padded = torch.FloatTensor(len(batch), batch[0][1].size(0), max_spec_len)
- wav_padded = torch.FloatTensor(len(batch), 1, max_wav_len)
- pitch_padded = torch.LongTensor(len(batch), max_pitch_len)
-
- text_padded.zero_()
- spec_padded.zero_()
- wav_padded.zero_()
- pitch_padded.zero_()
-
- for i in range(len(ids_sorted_decreasing)):
- row = batch[ids_sorted_decreasing[i]]
-
- text = row[0]
- text_padded[i, :text.size(0)] = text
- text_lengths[i] = text.size(0)
-
- spec = row[1]
- spec_padded[i, :, :spec.size(1)] = spec
- spec_lengths[i] = spec.size(1)
-
- wav = row[2]
- wav_padded[i, :, :wav.size(1)] = wav
- wav_lengths[i] = wav.size(1)
-
- pitch = row[3]
- pitch_padded[i, :pitch.size(0)] = pitch
-
- sid[i] = row[4]
-
- if self.return_ids:
- return text_padded, text_lengths, spec_padded, spec_lengths, wav_padded, wav_lengths, pitch_padded, sid, ids_sorted_decreasing
- return text_padded, text_lengths, spec_padded, spec_lengths, wav_padded, wav_lengths,pitch_padded , sid
-
-
-class DistributedBucketSampler(torch.utils.data.distributed.DistributedSampler):
- """
- Maintain similar input lengths in a batch.
- Length groups are specified by boundaries.
- Ex) boundaries = [b1, b2, b3] -> any batch is included either {x | b1 < length(x) <=b2} or {x | b2 < length(x) <= b3}.
-
- It removes samples which are not included in the boundaries.
- Ex) boundaries = [b1, b2, b3] -> any x s.t. length(x) <= b1 or length(x) > b3 are discarded.
- """
-
- def __init__(self, dataset, batch_size, boundaries, num_replicas=None, rank=None, shuffle=True):
- super().__init__(dataset, num_replicas=num_replicas, rank=rank, shuffle=shuffle)
- self.lengths = dataset.lengths
- self.batch_size = batch_size
- self.boundaries = boundaries
-
- self.buckets, self.num_samples_per_bucket = self._create_buckets()
- self.total_size = sum(self.num_samples_per_bucket)
- self.num_samples = self.total_size // self.num_replicas
-
- def _create_buckets(self):
- buckets = [[] for _ in range(len(self.boundaries) - 1)]
- for i in range(len(self.lengths)):
- length = self.lengths[i]
- idx_bucket = self._bisect(length)
- if idx_bucket != -1:
- buckets[idx_bucket].append(i)
-
- for i in range(len(buckets) - 1, 0, -1):
- if len(buckets[i]) == 0:
- buckets.pop(i)
- self.boundaries.pop(i + 1)
-
- num_samples_per_bucket = []
- for i in range(len(buckets)):
- len_bucket = len(buckets[i])
- total_batch_size = self.num_replicas * self.batch_size
- rem = (total_batch_size - (len_bucket % total_batch_size)) % total_batch_size
- num_samples_per_bucket.append(len_bucket + rem)
- return buckets, num_samples_per_bucket
-
- def __iter__(self):
- # deterministically shuffle based on epoch
- g = torch.Generator()
- g.manual_seed(self.epoch)
-
- indices = []
- if self.shuffle:
- for bucket in self.buckets:
- indices.append(torch.randperm(len(bucket), generator=g).tolist())
- else:
- for bucket in self.buckets:
- indices.append(list(range(len(bucket))))
-
- batches = []
- for i in range(len(self.buckets)):
- bucket = self.buckets[i]
- len_bucket = len(bucket)
- ids_bucket = indices[i]
- num_samples_bucket = self.num_samples_per_bucket[i]
-
- # add extra samples to make it evenly divisible
- rem = num_samples_bucket - len_bucket
- ids_bucket = ids_bucket + ids_bucket * (rem // len_bucket) + ids_bucket[:(rem % len_bucket)]
-
- # subsample
- ids_bucket = ids_bucket[self.rank::self.num_replicas]
-
- # batching
- for j in range(len(ids_bucket) // self.batch_size):
- batch = [bucket[idx] for idx in ids_bucket[j * self.batch_size:(j + 1) * self.batch_size]]
- batches.append(batch)
-
- if self.shuffle:
- batch_ids = torch.randperm(len(batches), generator=g).tolist()
- batches = [batches[i] for i in batch_ids]
- self.batches = batches
-
- assert len(self.batches) * self.batch_size == self.num_samples
- return iter(self.batches)
-
- def _bisect(self, x, lo=0, hi=None):
- if hi is None:
- hi = len(self.boundaries) - 1
-
- if hi > lo:
- mid = (hi + lo) // 2
- if self.boundaries[mid] < x and x <= self.boundaries[mid + 1]:
- return mid
- elif x <= self.boundaries[mid]:
- return self._bisect(x, lo, mid)
- else:
- return self._bisect(x, mid + 1, hi)
- else:
- return -1
-
- def __len__(self):
- return self.num_samples // self.batch_size
diff --git a/spaces/inplisQlawa/anything-midjourney-v4-1/License Key For Vivid Workshopdata Ati 12.1 !NEW!.md b/spaces/inplisQlawa/anything-midjourney-v4-1/License Key For Vivid Workshopdata Ati 12.1 !NEW!.md
deleted file mode 100644
index 1528a1a2fffacf051c6784f328597698d9e8ecb3..0000000000000000000000000000000000000000
--- a/spaces/inplisQlawa/anything-midjourney-v4-1/License Key For Vivid Workshopdata Ati 12.1 !NEW!.md
+++ /dev/null
@@ -1,86 +0,0 @@
-
-License Key for Vivid WorkshopData ATI 12.1
-If you are looking for a reliable and comprehensive software program for electrical motor diagnostics, repair and maintenance of European cars, you might want to consider Vivid WorkshopData ATI 12.1. This software provides you with up-to-date technical information, wiring diagrams, service schedules, fault codes and more. But how can you get a license key for Vivid WorkshopData ATI 12.1 and enjoy its full features? In this article, we will show you how to do that.
-What is Vivid WorkshopData ATI 12.1?
-Vivid WorkshopData ATI 12.1 is a software program that was developed by HaynesPro, a leading provider of automotive data solutions. It is designed to help professional mechanics and technicians with electrical motor diagnostics, repair and maintenance of European cars. It covers more than 25,000 models from over 80 vehicle manufacturers.
-license key for vivid workshopdata ati 12.1
Download File ››››› https://urlin.us/2uEvhF
-Some of the features of Vivid WorkshopData ATI 12.1 are:
-
-- Easy-to-use interface with intuitive navigation
-- Comprehensive and up-to-date technical information
-- Wiring diagrams with component locations and colors
-- Service schedules with service indicators and reset procedures
-- Fault codes with descriptions and causes
-- Component testing and measuring procedures
-- Repair times and labor costs
-- Technical bulletins and recalls
-- Online updates and support
-
-How to get a license key for Vivid WorkshopData ATI 12.1?
-To use Vivid WorkshopData ATI 12.1, you need to have a valid license key that activates the software on your computer. There are two ways to get a license key for Vivid WorkshopData ATI 12.1: buying it from an authorized dealer or cracking it from a third-party source.
-The first option is to buy a license key from an authorized dealer of HaynesPro. This is the safest and most legal way to get a license key for Vivid WorkshopData ATI 12.1. You can find a list of authorized dealers on the official website of HaynesPro: https://www.haynespro.com/en/dealers/. You can also contact HaynesPro directly to request a quote or a demo: https://www.haynespro.com/en/contact/.
-The second option is to crack a license key from a third-party source. This is the riskiest and most illegal way to get a license key for Vivid WorkshopData ATI 12.1. You can find various websites that offer cracked license keys for Vivid WorkshopData ATI 12.1, such as https://pletfaydeasac.weebly.com/vivid-workshopdata-ati-121rar-crackrar.html or https://trello.com/c/17GxEICS/27-license-key-for-vivid-workshopdata-ati-121. However, these websites are not trustworthy and may contain viruses, malware or spyware that can harm your computer or steal your personal information. Moreover, cracking a license key is a violation of the intellectual property rights of HaynesPro and may result in legal consequences.
-Conclusion
-Vivid WorkshopData ATI 12.1 is a software program that provides comprehensive and up-to-date technical information for electrical motor diagnostics, repair and maintenance of European cars. To use it, you need to have a valid license key that activates the software on your computer. You can either buy a license key from an authorized dealer of HaynesPro or crack a license key from a third-party source. However, we strongly recommend the first option as it is safer, legal and ethical.
-What are the benefits of using Vivid WorkshopData ATI 12.1?
-Using Vivid WorkshopData ATI 12.1 can bring you many benefits as a professional mechanic or technician. Some of the benefits are:
-
-
-- You can save time and money by accessing accurate and updated technical information in one place.
-- You can improve your skills and knowledge by learning from the best practices and tips from experts.
-- You can increase your customer satisfaction and loyalty by providing high-quality service and repair.
-- You can boost your reputation and credibility by using a trusted and reputable software program.
-- You can enhance your productivity and efficiency by using a user-friendly and intuitive interface.
-
-How to install and activate Vivid WorkshopData ATI 12.1 with license key?
-To install and activate Vivid WorkshopData ATI 12.1 with license key, you need to follow these steps:
-
-- Download the software program from the official website of HaynesPro or from an authorized dealer.
-- Extract the .rar file using a program like WinRAR or 7-Zip.
-- Run the setup.exe file and follow the instructions on the screen.
-- Enter the license key when prompted. You can find the license key in the email confirmation or in the package that you received.
-- Wait for the installation and activation process to complete.
-- Enjoy using Vivid WorkshopData ATI 12.1!
-
-Conclusion
-Vivid WorkshopData ATI 12.1 is a software program that provides comprehensive and up-to-date technical information for electrical motor diagnostics, repair and maintenance of European cars. To use it, you need to have a valid license key that activates the software on your computer. You can either buy a license key from an authorized dealer of HaynesPro or crack a license key from a third-party source. However, we strongly recommend the first option as it is safer, legal and ethical. Using Vivid WorkshopData ATI 12.1 can bring you many benefits as a professional mechanic or technician, such as saving time and money, improving your skills and knowledge, increasing your customer satisfaction and loyalty, boosting your reputation and credibility, and enhancing your productivity and efficiency.
-What are the alternatives to Vivid WorkshopData ATI 12.1?
-Vivid WorkshopData ATI 12.1 is not the only software program that offers technical information for electrical motor diagnostics, repair and maintenance of European cars. There are some alternatives that you can consider, such as:
-
-- Autodata: Autodata is a software program that provides technical information for over 34,000 models from over 142 manufacturers. It covers service schedules, wiring diagrams, diagnostics, repair instructions, technical specifications and more. You can buy a license key from an authorized dealer or subscribe online: https://www.autodata-group.com/.
-- Alldata: Alldata is a software program that provides technical information for over 38,000 models from over 175 manufacturers. It covers service schedules, wiring diagrams, diagnostics, repair instructions, technical bulletins and more. You can buy a license key from an authorized dealer or subscribe online: https://www.alldata.com/.
-- Mitchell: Mitchell is a software program that provides technical information for over 30,000 models from over 80 manufacturers. It covers service schedules, wiring diagrams, diagnostics, repair instructions, labor times and more. You can buy a license key from an authorized dealer or subscribe online: https://www.mitchell.com/.
-
-How to choose the best software program for your needs?
-To choose the best software program for your needs, you need to consider some factors, such as:
-
-- Your budget: Different software programs have different prices and payment options. You need to compare the costs and benefits of each software program and choose the one that fits your budget.
-- Your preferences: Different software programs have different features and interfaces. You need to test each software program and choose the one that suits your preferences and style.
-- Your requirements: Different software programs have different coverage and quality of technical information. You need to check each software program and choose the one that meets your requirements and expectations.
-
-Conclusion
-Vivid WorkshopData ATI 12.1 is a software program that provides comprehensive and up-to-date technical information for electrical motor diagnostics, repair and maintenance of European cars. To use it, you need to have a valid license key that activates the software on your computer. You can either buy a license key from an authorized dealer of HaynesPro or crack a license key from a third-party source. However, we strongly recommend the first option as it is safer, legal and ethical. Using Vivid WorkshopData ATI 12.1 can bring you many benefits as a professional mechanic or technician, such as saving time and money, improving your skills and knowledge, increasing your customer satisfaction and loyalty, boosting your reputation and credibility, and enhancing your productivity and efficiency. However, Vivid WorkshopData ATI 12.1 is not the only software program that offers technical information for electrical motor diagnostics, repair and maintenance of European cars. There are some alternatives that you can consider, such as Autodata, Alldata and Mitchell. To choose the best software program for your needs, you need to consider some factors, such as your budget, your preferences and your requirements.
-How to troubleshoot common problems with Vivid WorkshopData ATI 12.1?
-Vivid WorkshopData ATI 12.1 is a software program that usually works smoothly and efficiently. However, sometimes you may encounter some problems or errors that prevent you from using it properly. Here are some common problems and solutions that you can try:
-
-- Problem: The software does not start or crashes frequently.
-- Solution: Check if your computer meets the minimum system requirements for Vivid WorkshopData ATI 12.1. You can find them on the official website of HaynesPro: https://www.haynespro.com/en/system-requirements/. Also, make sure that you have installed the latest updates and patches for the software. You can download them from the official website of HaynesPro: https://www.haynespro.com/en/downloads/.
-- Problem: The license key is invalid or expired.
-- Solution: Check if you have entered the license key correctly and without any spaces or typos. Also, make sure that you have not used the license key on more than one computer or device. If you have bought the license key from an authorized dealer, contact them for assistance. If you have cracked the license key from a third-party source, you may need to find a new one.
-- Problem: The technical information is incomplete or inaccurate.
-- Solution: Check if you have selected the correct vehicle model and year from the database. Also, make sure that you have updated the software to the latest version and data release. You can download them from the official website of HaynesPro: https://www.haynespro.com/en/downloads/. If you still find any errors or discrepancies in the technical information, you can report them to HaynesPro: https://www.haynespro.com/en/contact/.
-
-How to get help and support for Vivid WorkshopData ATI 12.1?
-If you need any help or support for Vivid WorkshopData ATI 12.1, you can contact HaynesPro through various channels, such as:
-
-- Email: You can send an email to info@haynespro.com or support@haynespro.com and get a reply within 24 hours.
-- Phone: You can call +31 (0)35 603 62 70 from Monday to Friday between 9:00 and 17:00 CET.
-- Online: You can visit the official website of HaynesPro: https://www.haynespro.com/en/ and access the online help center, FAQ section, user manuals, video tutorials and more.
-- Social media: You can follow HaynesPro on Facebook, Twitter, LinkedIn and YouTube and get the latest news, updates and tips.
-
-Conclusion
-Vivid WorkshopData ATI 12.1 is a software program that provides comprehensive and up-to-date technical information for electrical motor diagnostics, repair and maintenance of European cars. To use it, you need to have a valid license key that activates the software on your computer. You can either buy a license key from an authorized dealer of HaynesPro or crack a license key from a third-party source. However, we strongly recommend the first option as it is safer, legal and ethical. Using Vivid WorkshopData ATI 12.1 can bring you many benefits as a professional mechanic or technician, such as saving time and money, improving your skills and knowledge, increasing your customer satisfaction and loyalty, boosting your reputation and credibility, and enhancing your productivity and efficiency. However, Vivid WorkshopData ATI 12.1 is not the only software program that offers technical information for electrical motor diagnostics, repair and maintenance of European cars. There are some alternatives that you can consider, such as Autodata, Alldata and Mitchell. To choose the best software program for your needs, you need to consider some factors, such as your budget, your preferences and your requirements. Moreover, if you encounter any problems or errors with Vivid WorkshopData ATI 12.1, you can try some troubleshooting tips or contact HaynesPro for help and support.
-Conclusion
-Vivid WorkshopData ATI 12.1 is a software program that provides comprehensive and up-to-date technical information for electrical motor diagnostics, repair and maintenance of European cars. To use it, you need to have a valid license key that activates the software on your computer. You can either buy a license key from an authorized dealer of HaynesPro or crack a license key from a third-party source. However, we strongly recommend the first option as it is safer, legal and ethical. Using Vivid WorkshopData ATI 12.1 can bring you many benefits as a professional mechanic or technician, such as saving time and money, improving your skills and knowledge, increasing your customer satisfaction and loyalty, boosting your reputation and credibility, and enhancing your productivity and efficiency. However, Vivid WorkshopData ATI 12.1 is not the only software program that offers technical information for electrical motor diagnostics, repair and maintenance of European cars. There are some alternatives that you can consider, such as Autodata, Alldata and Mitchell. To choose the best software program for your needs, you need to consider some factors, such as your budget, your preferences and your requirements. Moreover, if you encounter any problems or errors with Vivid WorkshopData ATI 12.1, you can try some troubleshooting tips or contact HaynesPro for help and support.
3cee63e6c2
-
-
\ No newline at end of file
diff --git a/spaces/inreVtussa/clothingai/Examples/American Truck Simulator 2016 Crack With License Key Free BETTER Download.md b/spaces/inreVtussa/clothingai/Examples/American Truck Simulator 2016 Crack With License Key Free BETTER Download.md
deleted file mode 100644
index e693f37944242d28d2410b3ada4c26e0fe301e83..0000000000000000000000000000000000000000
--- a/spaces/inreVtussa/clothingai/Examples/American Truck Simulator 2016 Crack With License Key Free BETTER Download.md
+++ /dev/null
@@ -1,17 +0,0 @@
-
-Here is what I created:
-
-American Truck Simulator 2016 Crack with License Key Free Download
-American Truck Simulator 2016 is a realistic and immersive simulation game that lets you drive across the USA in a variety of trucks. You can customize your vehicle, explore different routes and cities, and deliver cargo to various destinations. But what if you want to play the game without paying for it? That's where American Truck Simulator 2016 Crack comes in.
-American Truck Simulator 2016 Crack is a software tool that bypasses the game's activation process and allows you to play it for free. You don't need to buy the game or enter a license key to enjoy its features. All you need to do is download the crack file from a reliable source, install it on your PC, and run the game. It's that simple!
-American Truck Simulator 2016 Crack with License Key Free Download
Download ✓ https://tiurll.com/2uClPG
-However, before you download American Truck Simulator 2016 Crack, you should be aware of the risks involved. First of all, cracking a game is illegal and violates the terms of service of the developers and publishers. You could face legal consequences if you get caught. Second, downloading crack files from unknown sources could expose your PC to malware, viruses, or spyware. You could lose your data, compromise your security, or damage your system. Third, using a crack could affect the performance and quality of the game. You could experience bugs, glitches, crashes, or errors that ruin your gaming experience. You could also miss out on updates, patches, or online features that enhance the game.
-Therefore, we do not recommend using American Truck Simulator 2016 Crack or any other crack for that matter. If you want to play the game, you should buy it from a legitimate source and support the developers who worked hard to create it. You will get a better and safer gaming experience that way.
-Here is what I created:
-
-So, how can you play American Truck Simulator 2016 legally and safely? The answer is simple: buy the game from the official website or a trusted online store. You can choose from different editions and bundles that suit your budget and preferences. You can also get access to additional content, such as DLCs, mods, or community creations. You can also join the online community of truckers and share your experiences, tips, or feedback with other players.
-Buying the game will also ensure that you get the best possible gaming experience. You will be able to enjoy the game's realistic graphics, physics, and sound effects that make you feel like you are driving a real truck. You will also be able to explore the game's vast and diverse map that covers different regions and states of the USA. You will also be able to customize your truck with various parts, accessories, and paint jobs that reflect your personality and style.
-American Truck Simulator 2016 is a game that deserves your support and appreciation. It is a game that offers you hours of fun, challenge, and entertainment. It is a game that lets you live your dream of becoming a truck driver and traveling across the USA. It is a game that you should not miss out on. So, don't waste your time and money on cracks or pirated copies. Buy the game today and enjoy the ride!
- d5da3c52bf
-
-
\ No newline at end of file
diff --git a/spaces/inreVtussa/clothingai/Examples/Basic Electronics By Sanjay Sharma Pdf Free Download Hit.md b/spaces/inreVtussa/clothingai/Examples/Basic Electronics By Sanjay Sharma Pdf Free Download Hit.md
deleted file mode 100644
index 1b7f805fe4eb7f2d7c7cc809271780e649dc1e0b..0000000000000000000000000000000000000000
--- a/spaces/inreVtussa/clothingai/Examples/Basic Electronics By Sanjay Sharma Pdf Free Download Hit.md
+++ /dev/null
@@ -1,56 +0,0 @@
-
-Basic Electronics by Sanjay Sharma: A Comprehensive Guide for Beginners
-
-If you are looking for a book that covers the fundamentals of electronics in a clear and concise way, then you might want to check out Basic Electronics by Sanjay Sharma. This book is designed for students and amateurs who want to learn the theory and practice of electronics. It covers topics such as semiconductor devices, diode circuits, BJT circuits, FET circuits, feedback amplifiers, operational amplifiers, oscillators, digital electronics, and electronic instruments.
-
-Basic Electronics by Sanjay Sharma is a well-written and well-illustrated book that uses simple language and examples to explain complex concepts. It also includes numerous solved problems and exercises to help you test your understanding and apply your knowledge. The book is suitable for self-study as well as for classroom use.
-basic electronics by sanjay sharma pdf free download hit
Download File ➡ https://tiurll.com/2uCiKL
-
-One of the best features of this book is that it provides a free PDF download link for the readers. You can download the PDF version of the book from the following link: Basic Electronics by Sanjay Sharma PDF Free Download Hit. This link will take you to a website where you can access the PDF file of the book without any hassle. You can also find other useful resources and information on this website.
-
-Basic Electronics by Sanjay Sharma is a must-have book for anyone who wants to learn the basics of electronics and build their own circuits. It will help you gain a solid foundation in electronics and prepare you for more advanced topics. Whether you are a student, a hobbyist, or a professional, you will find this book useful and informative.
-
-So what are you waiting for? Download Basic Electronics by Sanjay Sharma PDF Free Download Hit today and start learning electronics!
-
-Basic Electronics Concepts
-
-Before you dive into the details of electronic circuits, you need to understand some basic concepts that are essential for electronics. These concepts include voltage, current, resistance, power, Ohm's law, Kirchhoff's laws, and Thevenin's theorem. These concepts will help you analyze and design electronic circuits and understand how they work.
-
-Voltage
-
-Voltage is the measure of electric potential difference between two points in a circuit. It is also called electromotive force (EMF) or potential. Voltage is the cause of electric current in a circuit. It is measured in volts (V).
-
-Current
-
-Current is the measure of electric charge flow through a conductor in a circuit. It is also called electric current or amperage. Current is the effect of voltage in a circuit. It is measured in amperes (A) or milliamperes (mA).
-
-Resistance
-
-Resistance is the measure of opposition to electric current in a circuit. It is also called electrical resistance or impedance. Resistance is the property of a material that determines how much current can flow through it for a given voltage. It is measured in ohms ($\Omega$) or kilohms (k$\Omega$).
-
-Power
-
-Power is the measure of electric energy consumed or delivered by a circuit element in a unit time. It is also called electrical power or wattage. Power is the product of voltage and current in a circuit. It is measured in watts (W) or milliwatts (mW).
-
-
-Ohm's Law
-
-Ohm's law is the fundamental relationship between voltage, current, and resistance in a circuit. It states that the voltage across a resistor is directly proportional to the current through it, and inversely proportional to its resistance. The mathematical expression of Ohm's law is:
-
-$$V = IR$$
-
-where V is the voltage in volts, I is the current in amperes, and R is the resistance in ohms.
-
-Kirchhoff's Laws
-
-Kirchhoff's laws are two rules that govern the conservation of charge and energy in a circuit. They are also called Kirchhoff's current law (KCL) and Kirchhoff's voltage law (KVL).
-
-KCL states that the algebraic sum of currents entering and leaving a node (or junction) in a circuit is zero. This means that the total charge entering a node is equal to the total charge leaving it.
-
-KVL states that the algebraic sum of voltages around any closed loop in a circuit is zero. This means that the total energy gained by charges moving around a loop is equal to the total energy lost by them.
-
-Thevenin's Theorem
-
-Thevenin's theorem is a technique that simplifies the analysis of complex circuits by replacing them with equivalent circuits consisting of a single voltage source and a single resistor. The theorem states that any linear circuit with two terminals can be replaced by an equivalent circuit with a voltage source equal to the open-circuit voltage across the terminals and a resistor equal to the equivalent resistance seen from the terminals.
d5da3c52bf
-
-
\ No newline at end of file
diff --git a/spaces/ipvikas/ALL_NLP_Tasks/README.md b/spaces/ipvikas/ALL_NLP_Tasks/README.md
deleted file mode 100644
index ad46a840f79244f3e4cf45523a47d51c753abd3d..0000000000000000000000000000000000000000
--- a/spaces/ipvikas/ALL_NLP_Tasks/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: ALL NLP Tasks
-emoji: 🌖
-colorFrom: indigo
-colorTo: blue
-sdk: gradio
-sdk_version: 3.1.4
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/itintelpro/MyCybersecHelper/README.md b/spaces/itintelpro/MyCybersecHelper/README.md
deleted file mode 100644
index 6ebb31b17de3b3c6db6ece3a7e6910a6ffcdca99..0000000000000000000000000000000000000000
--- a/spaces/itintelpro/MyCybersecHelper/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: MyCybersecHelper
-emoji: 📉
-colorFrom: yellow
-colorTo: purple
-sdk: gradio
-sdk_version: 3.24.1
-app_file: app.py
-pinned: false
-license: other
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/ixciel/img-to-music/constants.py b/spaces/ixciel/img-to-music/constants.py
deleted file mode 100644
index 86863d1b778d4c66f0d8e1e0b699f1bb937c1d50..0000000000000000000000000000000000000000
--- a/spaces/ixciel/img-to-music/constants.py
+++ /dev/null
@@ -1,9 +0,0 @@
-import numpy as np
-import os
-
-MUBERT_LICENSE = os.environ.get('MUBERT_LICENSE')
-MUBERT_TOKEN = os.environ.get('MUBERT_TOKEN')
-
-MUBERT_MODE = "loop"
-MUBERT_TAGS_STRING = 'tribal,action,kids,neo-classic,run 130,pumped,jazz / funk,ethnic,dubtechno,reggae,acid jazz,liquidfunk,funk,witch house,tech house,underground,artists,mystical,disco,sensorium,r&b,agender,psychedelic trance / psytrance,peaceful,run 140,piano,run 160,setting,meditation,christmas,ambient,horror,cinematic,electro house,idm,bass,minimal,underscore,drums,glitchy,beautiful,technology,tribal house,country pop,jazz & funk,documentary,space,classical,valentines,chillstep,experimental,trap,new jack swing,drama,post-rock,tense,corporate,neutral,happy,analog,funky,spiritual,sberzvuk special,chill hop,dramatic,catchy,holidays,fitness 90,optimistic,orchestra,acid techno,energizing,romantic,minimal house,breaks,hyper pop,warm up,dreamy,dark,urban,microfunk,dub,nu disco,vogue,keys,hardcore,aggressive,indie,electro funk,beauty,relaxing,trance,pop,hiphop,soft,acoustic,chillrave / ethno-house,deep techno,angry,dance,fun,dubstep,tropical,latin pop,heroic,world music,inspirational,uplifting,atmosphere,art,epic,advertising,chillout,scary,spooky,slow ballad,saxophone,summer,erotic,jazzy,energy 100,kara mar,xmas,atmospheric,indie pop,hip-hop,yoga,reggaeton,lounge,travel,running,folk,chillrave & ethno-house,detective,darkambient,chill,fantasy,minimal techno,special,night,tropical house,downtempo,lullaby,meditative,upbeat,glitch hop,fitness,neurofunk,sexual,indie rock,future pop,jazz,cyberpunk,melancholic,happy hardcore,family / kids,synths,electric guitar,comedy,psychedelic trance & psytrance,edm,psychedelic rock,calm,zen,bells,podcast,melodic house,ethnic percussion,nature,heavy,bassline,indie dance,techno,drumnbass,synth pop,vaporwave,sad,8-bit,chillgressive,deep,orchestral,futuristic,hardtechno,nostalgic,big room,sci-fi,tutorial,joyful,pads,minimal 170,drill,ethnic 108,amusing,sleepy ambient,psychill,italo disco,lofi,house,acoustic guitar,bassline house,rock,k-pop,synthwave,deep house,electronica,gabber,nightlife,sport & fitness,road trip,celebration,electro,disco house,electronic'
-MUBERT_TAGS = np.array(MUBERT_TAGS_STRING.split(','))
\ No newline at end of file
diff --git a/spaces/jackli888/stable-diffusion-webui/javascript/progressbar.js b/spaces/jackli888/stable-diffusion-webui/javascript/progressbar.js
deleted file mode 100644
index ff6d757bae88f5f622767376e5315b9acf8271cd..0000000000000000000000000000000000000000
--- a/spaces/jackli888/stable-diffusion-webui/javascript/progressbar.js
+++ /dev/null
@@ -1,243 +0,0 @@
-// code related to showing and updating progressbar shown as the image is being made
-
-
-galleries = {}
-storedGallerySelections = {}
-galleryObservers = {}
-
-function rememberGallerySelection(id_gallery){
- storedGallerySelections[id_gallery] = getGallerySelectedIndex(id_gallery)
-}
-
-function getGallerySelectedIndex(id_gallery){
- let galleryButtons = gradioApp().querySelectorAll('#'+id_gallery+' .gallery-item')
- let galleryBtnSelected = gradioApp().querySelector('#'+id_gallery+' .gallery-item.\\!ring-2')
-
- let currentlySelectedIndex = -1
- galleryButtons.forEach(function(v, i){ if(v==galleryBtnSelected) { currentlySelectedIndex = i } })
-
- return currentlySelectedIndex
-}
-
-// this is a workaround for https://github.com/gradio-app/gradio/issues/2984
-function check_gallery(id_gallery){
- let gallery = gradioApp().getElementById(id_gallery)
- // if gallery has no change, no need to setting up observer again.
- if (gallery && galleries[id_gallery] !== gallery){
- galleries[id_gallery] = gallery;
- if(galleryObservers[id_gallery]){
- galleryObservers[id_gallery].disconnect();
- }
-
- storedGallerySelections[id_gallery] = -1
-
- galleryObservers[id_gallery] = new MutationObserver(function (){
- let galleryButtons = gradioApp().querySelectorAll('#'+id_gallery+' .gallery-item')
- let galleryBtnSelected = gradioApp().querySelector('#'+id_gallery+' .gallery-item.\\!ring-2')
- let currentlySelectedIndex = getGallerySelectedIndex(id_gallery)
- prevSelectedIndex = storedGallerySelections[id_gallery]
- storedGallerySelections[id_gallery] = -1
-
- if (prevSelectedIndex !== -1 && galleryButtons.length>prevSelectedIndex && !galleryBtnSelected) {
- // automatically re-open previously selected index (if exists)
- activeElement = gradioApp().activeElement;
- let scrollX = window.scrollX;
- let scrollY = window.scrollY;
-
- galleryButtons[prevSelectedIndex].click();
- showGalleryImage();
-
- // When the gallery button is clicked, it gains focus and scrolls itself into view
- // We need to scroll back to the previous position
- setTimeout(function (){
- window.scrollTo(scrollX, scrollY);
- }, 50);
-
- if(activeElement){
- // i fought this for about an hour; i don't know why the focus is lost or why this helps recover it
- // if someone has a better solution please by all means
- setTimeout(function (){
- activeElement.focus({
- preventScroll: true // Refocus the element that was focused before the gallery was opened without scrolling to it
- })
- }, 1);
- }
- }
- })
- galleryObservers[id_gallery].observe( gallery, { childList:true, subtree:false })
- }
-}
-
-onUiUpdate(function(){
- check_gallery('txt2img_gallery')
- check_gallery('img2img_gallery')
-})
-
-function request(url, data, handler, errorHandler){
- var xhr = new XMLHttpRequest();
- var url = url;
- xhr.open("POST", url, true);
- xhr.setRequestHeader("Content-Type", "application/json");
- xhr.onreadystatechange = function () {
- if (xhr.readyState === 4) {
- if (xhr.status === 200) {
- try {
- var js = JSON.parse(xhr.responseText);
- handler(js)
- } catch (error) {
- console.error(error);
- errorHandler()
- }
- } else{
- errorHandler()
- }
- }
- };
- var js = JSON.stringify(data);
- xhr.send(js);
-}
-
-function pad2(x){
- return x<10 ? '0'+x : x
-}
-
-function formatTime(secs){
- if(secs > 3600){
- return pad2(Math.floor(secs/60/60)) + ":" + pad2(Math.floor(secs/60)%60) + ":" + pad2(Math.floor(secs)%60)
- } else if(secs > 60){
- return pad2(Math.floor(secs/60)) + ":" + pad2(Math.floor(secs)%60)
- } else{
- return Math.floor(secs) + "s"
- }
-}
-
-function setTitle(progress){
- var title = 'Stable Diffusion'
-
- if(opts.show_progress_in_title && progress){
- title = '[' + progress.trim() + '] ' + title;
- }
-
- if(document.title != title){
- document.title = title;
- }
-}
-
-
-function randomId(){
- return "task(" + Math.random().toString(36).slice(2, 7) + Math.random().toString(36).slice(2, 7) + Math.random().toString(36).slice(2, 7)+")"
-}
-
-// starts sending progress requests to "/internal/progress" uri, creating progressbar above progressbarContainer element and
-// preview inside gallery element. Cleans up all created stuff when the task is over and calls atEnd.
-// calls onProgress every time there is a progress update
-function requestProgress(id_task, progressbarContainer, gallery, atEnd, onProgress){
- var dateStart = new Date()
- var wasEverActive = false
- var parentProgressbar = progressbarContainer.parentNode
- var parentGallery = gallery ? gallery.parentNode : null
-
- var divProgress = document.createElement('div')
- divProgress.className='progressDiv'
- divProgress.style.display = opts.show_progressbar ? "" : "none"
- var divInner = document.createElement('div')
- divInner.className='progress'
-
- divProgress.appendChild(divInner)
- parentProgressbar.insertBefore(divProgress, progressbarContainer)
-
- if(parentGallery){
- var livePreview = document.createElement('div')
- livePreview.className='livePreview'
- parentGallery.insertBefore(livePreview, gallery)
- }
-
- var removeProgressBar = function(){
- setTitle("")
- parentProgressbar.removeChild(divProgress)
- if(parentGallery) parentGallery.removeChild(livePreview)
- atEnd()
- }
-
- var fun = function(id_task, id_live_preview){
- request("./internal/progress", {"id_task": id_task, "id_live_preview": id_live_preview}, function(res){
- if(res.completed){
- removeProgressBar()
- return
- }
-
- var rect = progressbarContainer.getBoundingClientRect()
-
- if(rect.width){
- divProgress.style.width = rect.width + "px";
- }
-
- progressText = ""
-
- divInner.style.width = ((res.progress || 0) * 100.0) + '%'
- divInner.style.background = res.progress ? "" : "transparent"
-
- if(res.progress > 0){
- progressText = ((res.progress || 0) * 100.0).toFixed(0) + '%'
- }
-
- if(res.eta){
- progressText += " ETA: " + formatTime(res.eta)
- }
-
-
- setTitle(progressText)
-
- if(res.textinfo && res.textinfo.indexOf("\n") == -1){
- progressText = res.textinfo + " " + progressText
- }
-
- divInner.textContent = progressText
-
- var elapsedFromStart = (new Date() - dateStart) / 1000
-
- if(res.active) wasEverActive = true;
-
- if(! res.active && wasEverActive){
- removeProgressBar()
- return
- }
-
- if(elapsedFromStart > 5 && !res.queued && !res.active){
- removeProgressBar()
- return
- }
-
-
- if(res.live_preview && gallery){
- var rect = gallery.getBoundingClientRect()
- if(rect.width){
- livePreview.style.width = rect.width + "px"
- livePreview.style.height = rect.height + "px"
- }
-
- var img = new Image();
- img.onload = function() {
- livePreview.appendChild(img)
- if(livePreview.childElementCount > 2){
- livePreview.removeChild(livePreview.firstElementChild)
- }
- }
- img.src = res.live_preview;
- }
-
-
- if(onProgress){
- onProgress(res)
- }
-
- setTimeout(() => {
- fun(id_task, res.id_live_preview);
- }, opts.live_preview_refresh_period || 500)
- }, function(){
- removeProgressBar()
- })
- }
-
- fun(id_task, 0)
-}
diff --git a/spaces/jackli888/stable-diffusion-webui/modules/esrgan_model.py b/spaces/jackli888/stable-diffusion-webui/modules/esrgan_model.py
deleted file mode 100644
index 80131c62cfeaa7f95455df55c45d6e62591adeee..0000000000000000000000000000000000000000
--- a/spaces/jackli888/stable-diffusion-webui/modules/esrgan_model.py
+++ /dev/null
@@ -1,233 +0,0 @@
-import os
-
-import numpy as np
-import torch
-from PIL import Image
-from basicsr.utils.download_util import load_file_from_url
-
-import modules.esrgan_model_arch as arch
-from modules import shared, modelloader, images, devices
-from modules.upscaler import Upscaler, UpscalerData
-from modules.shared import opts
-
-
-
-def mod2normal(state_dict):
- # this code is copied from https://github.com/victorca25/iNNfer
- if 'conv_first.weight' in state_dict:
- crt_net = {}
- items = []
- for k, v in state_dict.items():
- items.append(k)
-
- crt_net['model.0.weight'] = state_dict['conv_first.weight']
- crt_net['model.0.bias'] = state_dict['conv_first.bias']
-
- for k in items.copy():
- if 'RDB' in k:
- ori_k = k.replace('RRDB_trunk.', 'model.1.sub.')
- if '.weight' in k:
- ori_k = ori_k.replace('.weight', '.0.weight')
- elif '.bias' in k:
- ori_k = ori_k.replace('.bias', '.0.bias')
- crt_net[ori_k] = state_dict[k]
- items.remove(k)
-
- crt_net['model.1.sub.23.weight'] = state_dict['trunk_conv.weight']
- crt_net['model.1.sub.23.bias'] = state_dict['trunk_conv.bias']
- crt_net['model.3.weight'] = state_dict['upconv1.weight']
- crt_net['model.3.bias'] = state_dict['upconv1.bias']
- crt_net['model.6.weight'] = state_dict['upconv2.weight']
- crt_net['model.6.bias'] = state_dict['upconv2.bias']
- crt_net['model.8.weight'] = state_dict['HRconv.weight']
- crt_net['model.8.bias'] = state_dict['HRconv.bias']
- crt_net['model.10.weight'] = state_dict['conv_last.weight']
- crt_net['model.10.bias'] = state_dict['conv_last.bias']
- state_dict = crt_net
- return state_dict
-
-
-def resrgan2normal(state_dict, nb=23):
- # this code is copied from https://github.com/victorca25/iNNfer
- if "conv_first.weight" in state_dict and "body.0.rdb1.conv1.weight" in state_dict:
- re8x = 0
- crt_net = {}
- items = []
- for k, v in state_dict.items():
- items.append(k)
-
- crt_net['model.0.weight'] = state_dict['conv_first.weight']
- crt_net['model.0.bias'] = state_dict['conv_first.bias']
-
- for k in items.copy():
- if "rdb" in k:
- ori_k = k.replace('body.', 'model.1.sub.')
- ori_k = ori_k.replace('.rdb', '.RDB')
- if '.weight' in k:
- ori_k = ori_k.replace('.weight', '.0.weight')
- elif '.bias' in k:
- ori_k = ori_k.replace('.bias', '.0.bias')
- crt_net[ori_k] = state_dict[k]
- items.remove(k)
-
- crt_net[f'model.1.sub.{nb}.weight'] = state_dict['conv_body.weight']
- crt_net[f'model.1.sub.{nb}.bias'] = state_dict['conv_body.bias']
- crt_net['model.3.weight'] = state_dict['conv_up1.weight']
- crt_net['model.3.bias'] = state_dict['conv_up1.bias']
- crt_net['model.6.weight'] = state_dict['conv_up2.weight']
- crt_net['model.6.bias'] = state_dict['conv_up2.bias']
-
- if 'conv_up3.weight' in state_dict:
- # modification supporting: https://github.com/ai-forever/Real-ESRGAN/blob/main/RealESRGAN/rrdbnet_arch.py
- re8x = 3
- crt_net['model.9.weight'] = state_dict['conv_up3.weight']
- crt_net['model.9.bias'] = state_dict['conv_up3.bias']
-
- crt_net[f'model.{8+re8x}.weight'] = state_dict['conv_hr.weight']
- crt_net[f'model.{8+re8x}.bias'] = state_dict['conv_hr.bias']
- crt_net[f'model.{10+re8x}.weight'] = state_dict['conv_last.weight']
- crt_net[f'model.{10+re8x}.bias'] = state_dict['conv_last.bias']
-
- state_dict = crt_net
- return state_dict
-
-
-def infer_params(state_dict):
- # this code is copied from https://github.com/victorca25/iNNfer
- scale2x = 0
- scalemin = 6
- n_uplayer = 0
- plus = False
-
- for block in list(state_dict):
- parts = block.split(".")
- n_parts = len(parts)
- if n_parts == 5 and parts[2] == "sub":
- nb = int(parts[3])
- elif n_parts == 3:
- part_num = int(parts[1])
- if (part_num > scalemin
- and parts[0] == "model"
- and parts[2] == "weight"):
- scale2x += 1
- if part_num > n_uplayer:
- n_uplayer = part_num
- out_nc = state_dict[block].shape[0]
- if not plus and "conv1x1" in block:
- plus = True
-
- nf = state_dict["model.0.weight"].shape[0]
- in_nc = state_dict["model.0.weight"].shape[1]
- out_nc = out_nc
- scale = 2 ** scale2x
-
- return in_nc, out_nc, nf, nb, plus, scale
-
-
-class UpscalerESRGAN(Upscaler):
- def __init__(self, dirname):
- self.name = "ESRGAN"
- self.model_url = "https://github.com/cszn/KAIR/releases/download/v1.0/ESRGAN.pth"
- self.model_name = "ESRGAN_4x"
- self.scalers = []
- self.user_path = dirname
- super().__init__()
- model_paths = self.find_models(ext_filter=[".pt", ".pth"])
- scalers = []
- if len(model_paths) == 0:
- scaler_data = UpscalerData(self.model_name, self.model_url, self, 4)
- scalers.append(scaler_data)
- for file in model_paths:
- if "http" in file:
- name = self.model_name
- else:
- name = modelloader.friendly_name(file)
-
- scaler_data = UpscalerData(name, file, self, 4)
- self.scalers.append(scaler_data)
-
- def do_upscale(self, img, selected_model):
- model = self.load_model(selected_model)
- if model is None:
- return img
- model.to(devices.device_esrgan)
- img = esrgan_upscale(model, img)
- return img
-
- def load_model(self, path: str):
- if "http" in path:
- filename = load_file_from_url(url=self.model_url, model_dir=self.model_path,
- file_name="%s.pth" % self.model_name,
- progress=True)
- else:
- filename = path
- if not os.path.exists(filename) or filename is None:
- print("Unable to load %s from %s" % (self.model_path, filename))
- return None
-
- state_dict = torch.load(filename, map_location='cpu' if devices.device_esrgan.type == 'mps' else None)
-
- if "params_ema" in state_dict:
- state_dict = state_dict["params_ema"]
- elif "params" in state_dict:
- state_dict = state_dict["params"]
- num_conv = 16 if "realesr-animevideov3" in filename else 32
- model = arch.SRVGGNetCompact(num_in_ch=3, num_out_ch=3, num_feat=64, num_conv=num_conv, upscale=4, act_type='prelu')
- model.load_state_dict(state_dict)
- model.eval()
- return model
-
- if "body.0.rdb1.conv1.weight" in state_dict and "conv_first.weight" in state_dict:
- nb = 6 if "RealESRGAN_x4plus_anime_6B" in filename else 23
- state_dict = resrgan2normal(state_dict, nb)
- elif "conv_first.weight" in state_dict:
- state_dict = mod2normal(state_dict)
- elif "model.0.weight" not in state_dict:
- raise Exception("The file is not a recognized ESRGAN model.")
-
- in_nc, out_nc, nf, nb, plus, mscale = infer_params(state_dict)
-
- model = arch.RRDBNet(in_nc=in_nc, out_nc=out_nc, nf=nf, nb=nb, upscale=mscale, plus=plus)
- model.load_state_dict(state_dict)
- model.eval()
-
- return model
-
-
-def upscale_without_tiling(model, img):
- img = np.array(img)
- img = img[:, :, ::-1]
- img = np.ascontiguousarray(np.transpose(img, (2, 0, 1))) / 255
- img = torch.from_numpy(img).float()
- img = img.unsqueeze(0).to(devices.device_esrgan)
- with torch.no_grad():
- output = model(img)
- output = output.squeeze().float().cpu().clamp_(0, 1).numpy()
- output = 255. * np.moveaxis(output, 0, 2)
- output = output.astype(np.uint8)
- output = output[:, :, ::-1]
- return Image.fromarray(output, 'RGB')
-
-
-def esrgan_upscale(model, img):
- if opts.ESRGAN_tile == 0:
- return upscale_without_tiling(model, img)
-
- grid = images.split_grid(img, opts.ESRGAN_tile, opts.ESRGAN_tile, opts.ESRGAN_tile_overlap)
- newtiles = []
- scale_factor = 1
-
- for y, h, row in grid.tiles:
- newrow = []
- for tiledata in row:
- x, w, tile = tiledata
-
- output = upscale_without_tiling(model, tile)
- scale_factor = output.width // tile.width
-
- newrow.append([x * scale_factor, w * scale_factor, output])
- newtiles.append([y * scale_factor, h * scale_factor, newrow])
-
- newgrid = images.Grid(newtiles, grid.tile_w * scale_factor, grid.tile_h * scale_factor, grid.image_w * scale_factor, grid.image_h * scale_factor, grid.overlap * scale_factor)
- output = images.combine_grid(newgrid)
- return output
diff --git a/spaces/jhwen/bingo/src/components/learn-more.tsx b/spaces/jhwen/bingo/src/components/learn-more.tsx
deleted file mode 100644
index a64459ee7900a612292e117a6bda96ee9260990f..0000000000000000000000000000000000000000
--- a/spaces/jhwen/bingo/src/components/learn-more.tsx
+++ /dev/null
@@ -1,39 +0,0 @@
-import React from 'react'
-import { SourceAttribution } from '@/lib/bots/bing/types'
-
-export interface LearnMoreProps {
- sourceAttributions?: SourceAttribution[]
-}
-
-export function LearnMore({ sourceAttributions }: LearnMoreProps) {
- if (!sourceAttributions?.length) {
- return null
- }
-
- return (
-
- 了解详细信息:
-
-
- {sourceAttributions.map((attribution, index) => {
- const { providerDisplayName, seeMoreUrl } = attribution
- const { host } = new URL(seeMoreUrl)
- return (
-
- {index + 1}. {host}
-
- )
- })}
-
-
-
- )
-}
diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/Crypto/Signature/DSS.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/Crypto/Signature/DSS.py
deleted file mode 100644
index fa848179ef108ed53168b0bf6f2082196696a1e1..0000000000000000000000000000000000000000
--- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/Crypto/Signature/DSS.py
+++ /dev/null
@@ -1,403 +0,0 @@
-#
-# Signature/DSS.py : DSS.py
-#
-# ===================================================================
-#
-# Copyright (c) 2014, Legrandin
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-#
-# 1. Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-# 2. Redistributions in binary form must reproduce the above copyright
-# notice, this list of conditions and the following disclaimer in
-# the documentation and/or other materials provided with the
-# distribution.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-# POSSIBILITY OF SUCH DAMAGE.
-# ===================================================================
-
-from Crypto.Util.asn1 import DerSequence
-from Crypto.Util.number import long_to_bytes
-from Crypto.Math.Numbers import Integer
-
-from Crypto.Hash import HMAC
-from Crypto.PublicKey.ECC import EccKey
-from Crypto.PublicKey.DSA import DsaKey
-
-__all__ = ['DssSigScheme', 'new']
-
-
-class DssSigScheme(object):
- """A (EC)DSA signature object.
- Do not instantiate directly.
- Use :func:`Crypto.Signature.DSS.new`.
- """
-
- def __init__(self, key, encoding, order):
- """Create a new Digital Signature Standard (DSS) object.
-
- Do not instantiate this object directly,
- use `Crypto.Signature.DSS.new` instead.
- """
-
- self._key = key
- self._encoding = encoding
- self._order = order
-
- self._order_bits = self._order.size_in_bits()
- self._order_bytes = (self._order_bits - 1) // 8 + 1
-
- def can_sign(self):
- """Return ``True`` if this signature object can be used
- for signing messages."""
-
- return self._key.has_private()
-
- def _compute_nonce(self, msg_hash):
- raise NotImplementedError("To be provided by subclasses")
-
- def _valid_hash(self, msg_hash):
- raise NotImplementedError("To be provided by subclasses")
-
- def sign(self, msg_hash):
- """Compute the DSA/ECDSA signature of a message.
-
- Args:
- msg_hash (hash object):
- The hash that was carried out over the message.
- The object belongs to the :mod:`Crypto.Hash` package.
- Under mode ``'fips-186-3'``, the hash must be a FIPS
- approved secure hash (SHA-2 or SHA-3).
-
- :return: The signature as ``bytes``
- :raise ValueError: if the hash algorithm is incompatible to the (EC)DSA key
- :raise TypeError: if the (EC)DSA key has no private half
- """
-
- if not self._key.has_private():
- raise TypeError("Private key is needed to sign")
-
- if not self._valid_hash(msg_hash):
- raise ValueError("Hash is not sufficiently strong")
-
- # Generate the nonce k (critical!)
- nonce = self._compute_nonce(msg_hash)
-
- # Perform signature using the raw API
- z = Integer.from_bytes(msg_hash.digest()[:self._order_bytes])
- sig_pair = self._key._sign(z, nonce)
-
- # Encode the signature into a single byte string
- if self._encoding == 'binary':
- output = b"".join([long_to_bytes(x, self._order_bytes)
- for x in sig_pair])
- else:
- # Dss-sig ::= SEQUENCE {
- # r INTEGER,
- # s INTEGER
- # }
- # Ecdsa-Sig-Value ::= SEQUENCE {
- # r INTEGER,
- # s INTEGER
- # }
- output = DerSequence(sig_pair).encode()
-
- return output
-
- def verify(self, msg_hash, signature):
- """Check if a certain (EC)DSA signature is authentic.
-
- Args:
- msg_hash (hash object):
- The hash that was carried out over the message.
- This is an object belonging to the :mod:`Crypto.Hash` module.
- Under mode ``'fips-186-3'``, the hash must be a FIPS
- approved secure hash (SHA-2 or SHA-3).
-
- signature (``bytes``):
- The signature that needs to be validated.
-
- :raise ValueError: if the signature is not authentic
- """
-
- if not self._valid_hash(msg_hash):
- raise ValueError("Hash is not sufficiently strong")
-
- if self._encoding == 'binary':
- if len(signature) != (2 * self._order_bytes):
- raise ValueError("The signature is not authentic (length)")
- r_prime, s_prime = [Integer.from_bytes(x)
- for x in (signature[:self._order_bytes],
- signature[self._order_bytes:])]
- else:
- try:
- der_seq = DerSequence().decode(signature, strict=True)
- except (ValueError, IndexError):
- raise ValueError("The signature is not authentic (DER)")
- if len(der_seq) != 2 or not der_seq.hasOnlyInts():
- raise ValueError("The signature is not authentic (DER content)")
- r_prime, s_prime = Integer(der_seq[0]), Integer(der_seq[1])
-
- if not (0 < r_prime < self._order) or not (0 < s_prime < self._order):
- raise ValueError("The signature is not authentic (d)")
-
- z = Integer.from_bytes(msg_hash.digest()[:self._order_bytes])
- result = self._key._verify(z, (r_prime, s_prime))
- if not result:
- raise ValueError("The signature is not authentic")
- # Make PyCrypto code to fail
- return False
-
-
-class DeterministicDsaSigScheme(DssSigScheme):
- # Also applicable to ECDSA
-
- def __init__(self, key, encoding, order, private_key):
- super(DeterministicDsaSigScheme, self).__init__(key, encoding, order)
- self._private_key = private_key
-
- def _bits2int(self, bstr):
- """See 2.3.2 in RFC6979"""
-
- result = Integer.from_bytes(bstr)
- q_len = self._order.size_in_bits()
- b_len = len(bstr) * 8
- if b_len > q_len:
- # Only keep leftmost q_len bits
- result >>= (b_len - q_len)
- return result
-
- def _int2octets(self, int_mod_q):
- """See 2.3.3 in RFC6979"""
-
- assert 0 < int_mod_q < self._order
- return long_to_bytes(int_mod_q, self._order_bytes)
-
- def _bits2octets(self, bstr):
- """See 2.3.4 in RFC6979"""
-
- z1 = self._bits2int(bstr)
- if z1 < self._order:
- z2 = z1
- else:
- z2 = z1 - self._order
- return self._int2octets(z2)
-
- def _compute_nonce(self, mhash):
- """Generate k in a deterministic way"""
-
- # See section 3.2 in RFC6979.txt
- # Step a
- h1 = mhash.digest()
- # Step b
- mask_v = b'\x01' * mhash.digest_size
- # Step c
- nonce_k = b'\x00' * mhash.digest_size
-
- for int_oct in (b'\x00', b'\x01'):
- # Step d/f
- nonce_k = HMAC.new(nonce_k,
- mask_v + int_oct +
- self._int2octets(self._private_key) +
- self._bits2octets(h1), mhash).digest()
- # Step e/g
- mask_v = HMAC.new(nonce_k, mask_v, mhash).digest()
-
- nonce = -1
- while not (0 < nonce < self._order):
- # Step h.C (second part)
- if nonce != -1:
- nonce_k = HMAC.new(nonce_k, mask_v + b'\x00',
- mhash).digest()
- mask_v = HMAC.new(nonce_k, mask_v, mhash).digest()
-
- # Step h.A
- mask_t = b""
-
- # Step h.B
- while len(mask_t) < self._order_bytes:
- mask_v = HMAC.new(nonce_k, mask_v, mhash).digest()
- mask_t += mask_v
-
- # Step h.C (first part)
- nonce = self._bits2int(mask_t)
- return nonce
-
- def _valid_hash(self, msg_hash):
- return True
-
-
-class FipsDsaSigScheme(DssSigScheme):
-
- #: List of L (bit length of p) and N (bit length of q) combinations
- #: that are allowed by FIPS 186-3. The security level is provided in
- #: Table 2 of FIPS 800-57 (rev3).
- _fips_186_3_L_N = (
- (1024, 160), # 80 bits (SHA-1 or stronger)
- (2048, 224), # 112 bits (SHA-224 or stronger)
- (2048, 256), # 128 bits (SHA-256 or stronger)
- (3072, 256) # 256 bits (SHA-512)
- )
-
- def __init__(self, key, encoding, order, randfunc):
- super(FipsDsaSigScheme, self).__init__(key, encoding, order)
- self._randfunc = randfunc
-
- L = Integer(key.p).size_in_bits()
- if (L, self._order_bits) not in self._fips_186_3_L_N:
- error = ("L/N (%d, %d) is not compliant to FIPS 186-3"
- % (L, self._order_bits))
- raise ValueError(error)
-
- def _compute_nonce(self, msg_hash):
- # hash is not used
- return Integer.random_range(min_inclusive=1,
- max_exclusive=self._order,
- randfunc=self._randfunc)
-
- def _valid_hash(self, msg_hash):
- """Verify that SHA-1, SHA-2 or SHA-3 are used"""
- return (msg_hash.oid == "1.3.14.3.2.26" or
- msg_hash.oid.startswith("2.16.840.1.101.3.4.2."))
-
-
-class FipsEcDsaSigScheme(DssSigScheme):
-
- def __init__(self, key, encoding, order, randfunc):
- super(FipsEcDsaSigScheme, self).__init__(key, encoding, order)
- self._randfunc = randfunc
-
- def _compute_nonce(self, msg_hash):
- return Integer.random_range(min_inclusive=1,
- max_exclusive=self._key._curve.order,
- randfunc=self._randfunc)
-
- def _valid_hash(self, msg_hash):
- """Verify that the strength of the hash matches or exceeds
- the strength of the EC. We fail if the hash is too weak."""
-
- modulus_bits = self._key.pointQ.size_in_bits()
-
- # SHS: SHA-2, SHA-3, truncated SHA-512
- sha224 = ("2.16.840.1.101.3.4.2.4", "2.16.840.1.101.3.4.2.7", "2.16.840.1.101.3.4.2.5")
- sha256 = ("2.16.840.1.101.3.4.2.1", "2.16.840.1.101.3.4.2.8", "2.16.840.1.101.3.4.2.6")
- sha384 = ("2.16.840.1.101.3.4.2.2", "2.16.840.1.101.3.4.2.9")
- sha512 = ("2.16.840.1.101.3.4.2.3", "2.16.840.1.101.3.4.2.10")
- shs = sha224 + sha256 + sha384 + sha512
-
- try:
- result = msg_hash.oid in shs
- except AttributeError:
- result = False
- return result
-
-
-def new(key, mode, encoding='binary', randfunc=None):
- """Create a signature object :class:`DssSigScheme` that
- can perform (EC)DSA signature or verification.
-
- .. note::
- Refer to `NIST SP 800 Part 1 Rev 4`_ (or newer release) for an
- overview of the recommended key lengths.
-
- Args:
- key (:class:`Crypto.PublicKey.DSA` or :class:`Crypto.PublicKey.ECC`):
- The key to use for computing the signature (*private* keys only)
- or for verifying one.
- For DSA keys, let ``L`` and ``N`` be the bit lengths of the modulus ``p``
- and of ``q``: the pair ``(L,N)`` must appear in the following list,
- in compliance to section 4.2 of `FIPS 186-4`_:
-
- - (1024, 160) *legacy only; do not create new signatures with this*
- - (2048, 224) *deprecated; do not create new signatures with this*
- - (2048, 256)
- - (3072, 256)
-
- For ECC, only keys over P-224, P-256, P-384, and P-521 are accepted.
-
- mode (string):
- The parameter can take these values:
-
- - ``'fips-186-3'``. The signature generation is randomized and carried out
- according to `FIPS 186-3`_: the nonce ``k`` is taken from the RNG.
- - ``'deterministic-rfc6979'``. The signature generation is not
- randomized. See RFC6979_.
-
- encoding (string):
- How the signature is encoded. This value determines the output of
- :meth:`sign` and the input to :meth:`verify`.
-
- The following values are accepted:
-
- - ``'binary'`` (default), the signature is the raw concatenation
- of ``r`` and ``s``. It is defined in the IEEE P.1363 standard.
- For DSA, the size in bytes of the signature is ``N/4`` bytes
- (e.g. 64 for ``N=256``).
- For ECDSA, the signature is always twice the length of a point
- coordinate (e.g. 64 bytes for P-256).
-
- - ``'der'``, the signature is a ASN.1 DER SEQUENCE
- with two INTEGERs (``r`` and ``s``). It is defined in RFC3279_.
- The size of the signature is variable.
-
- randfunc (callable):
- A function that returns random ``bytes``, of a given length.
- If omitted, the internal RNG is used.
- Only applicable for the *'fips-186-3'* mode.
-
- .. _FIPS 186-3: http://csrc.nist.gov/publications/fips/fips186-3/fips_186-3.pdf
- .. _FIPS 186-4: http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-4.pdf
- .. _NIST SP 800 Part 1 Rev 4: http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-57pt1r4.pdf
- .. _RFC6979: http://tools.ietf.org/html/rfc6979
- .. _RFC3279: https://tools.ietf.org/html/rfc3279#section-2.2.2
- """
-
- # The goal of the 'mode' parameter is to avoid to
- # have the current version of the standard as default.
- #
- # Over time, such version will be superseded by (for instance)
- # FIPS 186-4 and it will be odd to have -3 as default.
-
- if encoding not in ('binary', 'der'):
- raise ValueError("Unknown encoding '%s'" % encoding)
-
- if isinstance(key, EccKey):
- order = key._curve.order
- private_key_attr = 'd'
- if key._curve.name == "ed25519":
- raise ValueError("ECC key is not on a NIST P curve")
- elif isinstance(key, DsaKey):
- order = Integer(key.q)
- private_key_attr = 'x'
- else:
- raise ValueError("Unsupported key type " + str(type(key)))
-
- if key.has_private():
- private_key = getattr(key, private_key_attr)
- else:
- private_key = None
-
- if mode == 'deterministic-rfc6979':
- return DeterministicDsaSigScheme(key, encoding, order, private_key)
- elif mode == 'fips-186-3':
- if isinstance(key, EccKey):
- return FipsEcDsaSigScheme(key, encoding, order, randfunc)
- else:
- return FipsDsaSigScheme(key, encoding, order, randfunc)
- else:
- raise ValueError("Unknown DSS mode '%s'" % mode)
diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/dns/rdtypes/IN/SRV.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/dns/rdtypes/IN/SRV.py
deleted file mode 100644
index 84c5400728661ca94ff5a5dde4884a9a60771e35..0000000000000000000000000000000000000000
--- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/dns/rdtypes/IN/SRV.py
+++ /dev/null
@@ -1,76 +0,0 @@
-# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
-
-# Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose with or without fee is hereby granted,
-# provided that the above copyright notice and this permission notice
-# appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-import struct
-
-import dns.exception
-import dns.immutable
-import dns.name
-import dns.rdata
-import dns.rdtypes.util
-
-
-@dns.immutable.immutable
-class SRV(dns.rdata.Rdata):
-
- """SRV record"""
-
- # see: RFC 2782
-
- __slots__ = ["priority", "weight", "port", "target"]
-
- def __init__(self, rdclass, rdtype, priority, weight, port, target):
- super().__init__(rdclass, rdtype)
- self.priority = self._as_uint16(priority)
- self.weight = self._as_uint16(weight)
- self.port = self._as_uint16(port)
- self.target = self._as_name(target)
-
- def to_text(self, origin=None, relativize=True, **kw):
- target = self.target.choose_relativity(origin, relativize)
- return "%d %d %d %s" % (self.priority, self.weight, self.port, target)
-
- @classmethod
- def from_text(
- cls, rdclass, rdtype, tok, origin=None, relativize=True, relativize_to=None
- ):
- priority = tok.get_uint16()
- weight = tok.get_uint16()
- port = tok.get_uint16()
- target = tok.get_name(origin, relativize, relativize_to)
- return cls(rdclass, rdtype, priority, weight, port, target)
-
- def _to_wire(self, file, compress=None, origin=None, canonicalize=False):
- three_ints = struct.pack("!HHH", self.priority, self.weight, self.port)
- file.write(three_ints)
- self.target.to_wire(file, compress, origin, canonicalize)
-
- @classmethod
- def from_wire_parser(cls, rdclass, rdtype, parser, origin=None):
- (priority, weight, port) = parser.get_struct("!HHH")
- target = parser.get_name(origin)
- return cls(rdclass, rdtype, priority, weight, port, target)
-
- def _processing_priority(self):
- return self.priority
-
- def _processing_weight(self):
- return self.weight
-
- @classmethod
- def _processing_order(cls, iterable):
- return dns.rdtypes.util.weighted_processing_order(iterable)
diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/gpt_index/readers/faiss.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/gpt_index/readers/faiss.py
deleted file mode 100644
index cfa3e0bf58583699f4732023241ee76093a4c21a..0000000000000000000000000000000000000000
--- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/gpt_index/readers/faiss.py
+++ /dev/null
@@ -1,75 +0,0 @@
-"""Faiss reader."""
-
-from typing import Any, Dict, List
-
-import numpy as np
-
-from gpt_index.readers.base import BaseReader
-from gpt_index.readers.schema.base import Document
-
-
-class FaissReader(BaseReader):
- """Faiss reader.
-
- Retrieves documents through an existing in-memory Faiss index.
- These documents can then be used in a downstream LlamaIndex data structure.
- If you wish use Faiss itself as an index to to organize documents,
- insert documents, and perform queries on them, please use GPTFaissIndex.
-
- Args:
- faiss_index (faiss.Index): A Faiss Index object (required)
-
- """
-
- def __init__(self, index: Any):
- """Initialize with parameters."""
- import_err_msg = """
- `faiss` package not found. For instructions on
- how to install `faiss` please visit
- https://github.com/facebookresearch/faiss/wiki/Installing-Faiss
- """
- try:
- import faiss # noqa: F401
- except ImportError:
- raise ImportError(import_err_msg)
-
- self._index = index
-
- def load_data(
- self,
- query: np.ndarray,
- id_to_text_map: Dict[str, str],
- k: int = 4,
- separate_documents: bool = True,
- ) -> List[Document]:
- """Load data from Faiss.
-
- Args:
- query (np.ndarray): A 2D numpy array of query vectors.
- id_to_text_map (Dict[str, str]): A map from ID's to text.
- k (int): Number of nearest neighbors to retrieve. Defaults to 4.
- separate_documents (Optional[bool]): Whether to return separate
- documents. Defaults to True.
- Returns:
- List[Document]: A list of documents.
-
- """
- dists, indices = self._index.search(query, k)
- documents = []
- for qidx in range(indices.shape[0]):
- for didx in range(indices.shape[1]):
- doc_id = indices[qidx, didx]
- if doc_id not in id_to_text_map:
- raise ValueError(
- f"Document ID {doc_id} not found in id_to_text_map."
- )
- text = id_to_text_map[doc_id]
- documents.append(Document(text=text))
-
- if not separate_documents:
- # join all documents into one
- text_list = [doc.get_text() for doc in documents]
- text = "\n\n".join(text_list)
- documents = [Document(text=text)]
-
- return documents
diff --git a/spaces/jotarodadada/animeCf/README.md b/spaces/jotarodadada/animeCf/README.md
deleted file mode 100644
index 6f4e6157b97caed784727a651a2b99df5c38e8c8..0000000000000000000000000000000000000000
--- a/spaces/jotarodadada/animeCf/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: Real CUGAN
-emoji: 🐢
-colorFrom: gray
-colorTo: green
-sdk: gradio
-sdk_version: 3.6
-app_file: app.py
-pinned: false
-license: gpl-3.0
-duplicated_from: siyangyuan/animeCf
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/junkmind/SOTER/Dockerfile b/spaces/junkmind/SOTER/Dockerfile
deleted file mode 100644
index 8745c0c37a11c6bd3abf4a579dfae7742e9fd979..0000000000000000000000000000000000000000
--- a/spaces/junkmind/SOTER/Dockerfile
+++ /dev/null
@@ -1,54 +0,0 @@
-ARG PYTORCH="1.10.0"
-ARG CUDA="11.3"
-ARG CUDNN="8"
-
-FROM pytorch/pytorch:${PYTORCH}-cuda${CUDA}-cudnn${CUDNN}-devel
-
-ENV TORCH_NVCC_FLAGS="-Xfatbin -compress-all"
-ENV CMAKE_PREFIX_PATH="$(dirname $(which conda))/../"
-
-# Setting noninteractive build, setting up tzdata and configuring timezones
-ENV DEBIAN_FRONTEND=noninteractive
-ENV TZ=Europe/Berlin
-RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
-
-RUN apt-get update && apt-get install -y libglib2.0-0 libsm6 libxrender-dev libxext6 nano mc glances vim git \
- && apt-get clean \
- && rm -rf /var/lib/apt/lists/*
-
-# Install cython
-RUN conda install cython -y && conda clean --all
-
-# Installing APEX
-RUN pip install -U pip
-RUN git clone https://github.com/NVIDIA/apex
-RUN sed -i 's/check_cuda_torch_binary_vs_bare_metal(torch.utils.cpp_extension.CUDA_HOME)/pass/g' apex/setup.py
-RUN pip install -v --no-cache-dir --global-option="--cpp_ext" --global-option="--cuda_ext" ./apex
-RUN apt-get update -y
-RUN apt-get install build-essential cmake -y
-RUN apt-get install libopenblas-dev liblapack-dev -y
-RUN apt-get install libx11-dev libgtk-3-dev -y
-RUN pip install dlib
-RUN pip install facenet-pytorch
-RUN pip install albumentations==1.0.0 timm==0.4.12 pytorch_toolbelt tensorboardx
-RUN pip install cython jupyter jupyterlab ipykernel matplotlib tqdm pandas
-
-# download pretraned Imagenet models
-RUN apt install wget
-RUN wget https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_b7_ns-1dbc32de.pth -P /root/.cache/torch/hub/checkpoints/
-RUN wget https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_b5_ns-6f26d0cf.pth -P /root/.cache/torch/hub/checkpoints/
-
-# Setting the working directory
-WORKDIR /workspace
-
-# Copying the required codebase
-COPY . /workspace
-
-RUN chmod 777 preprocess_data.sh
-RUN chmod 777 train.sh
-RUN chmod 777 predict_submission.sh
-
-ENV PYTHONPATH=.
-
-CMD ["/bin/bash"]
-
diff --git a/spaces/justest/gpt4free/CONTRIBUTING.md b/spaces/justest/gpt4free/CONTRIBUTING.md
deleted file mode 100644
index 67aa60da1ce8322d31d71d9c8460f845f338bcde..0000000000000000000000000000000000000000
--- a/spaces/justest/gpt4free/CONTRIBUTING.md
+++ /dev/null
@@ -1,8 +0,0 @@
-
-
-### Please, follow these steps to contribute:
-1. Reverse a website from this list: [sites-to-reverse](https://github.com/xtekky/gpt4free/issues/40)
-2. Add it to [./testing](https://github.com/xtekky/gpt4free/tree/main/testing)
-3. Refractor it and add it to [./g4f](https://github.com/xtekky/gpt4free/tree/main/g4f)
-
-### We will be grateful to see you as a contributor!
diff --git a/spaces/kevinwang676/Bark-Voice-Cloning/app.py b/spaces/kevinwang676/Bark-Voice-Cloning/app.py
deleted file mode 100644
index dd274892625395e1d264dd7f8e7a600faa0a09b1..0000000000000000000000000000000000000000
--- a/spaces/kevinwang676/Bark-Voice-Cloning/app.py
+++ /dev/null
@@ -1,401 +0,0 @@
-from cProfile import label
-import dataclasses
-from distutils.command.check import check
-from doctest import Example
-import gradio as gr
-import os
-import sys
-import numpy as np
-import logging
-import torch
-import pytorch_seed
-import time
-
-from xml.sax import saxutils
-from bark.api import generate_with_settings
-from bark.api import save_as_prompt
-from util.settings import Settings
-#import nltk
-
-
-from bark import SAMPLE_RATE
-from cloning.clonevoice import clone_voice
-from bark.generation import SAMPLE_RATE, preload_models, _load_history_prompt, codec_decode
-from scipy.io.wavfile import write as write_wav
-from util.parseinput import split_and_recombine_text, build_ssml, is_ssml, create_clips_from_ssml
-from datetime import datetime
-from tqdm.auto import tqdm
-from util.helper import create_filename, add_id3_tag
-from swap_voice import swap_voice_from_audio
-from training.training_prepare import prepare_semantics_from_text, prepare_wavs_from_semantics
-from training.train import training_prepare_files, train
-
-settings = Settings('config.yaml')
-
-
-def generate_text_to_speech(text, selected_speaker, text_temp, waveform_temp, eos_prob, quick_generation, complete_settings, seed, batchcount, progress=gr.Progress(track_tqdm=True)):
- # Chunk the text into smaller pieces then combine the generated audio
-
- # generation settings
- if selected_speaker == 'None':
- selected_speaker = None
-
- voice_name = selected_speaker
-
- if text == None or len(text) < 1:
- if selected_speaker == None:
- raise gr.Error('No text entered!')
-
- # Extract audio data from speaker if no text and speaker selected
- voicedata = _load_history_prompt(voice_name)
- audio_arr = codec_decode(voicedata["fine_prompt"])
- result = create_filename(settings.output_folder_path, "None", "extract",".wav")
- save_wav(audio_arr, result)
- return result
-
- if batchcount < 1:
- batchcount = 1
-
-
- silenceshort = np.zeros(int((float(settings.silence_sentence) / 1000.0) * SAMPLE_RATE), dtype=np.int16) # quarter second of silence
- silencelong = np.zeros(int((float(settings.silence_speakers) / 1000.0) * SAMPLE_RATE), dtype=np.float32) # half a second of silence
- use_last_generation_as_history = "Use last generation as history" in complete_settings
- save_last_generation = "Save generation as Voice" in complete_settings
- for l in range(batchcount):
- currentseed = seed
- if seed != None and seed > 2**32 - 1:
- logger.warning(f"Seed {seed} > 2**32 - 1 (max), setting to random")
- currentseed = None
- if currentseed == None or currentseed <= 0:
- currentseed = np.random.default_rng().integers(1, 2**32 - 1)
- assert(0 < currentseed and currentseed < 2**32)
-
- progress(0, desc="Generating")
-
- full_generation = None
-
- all_parts = []
- complete_text = ""
- text = text.lstrip()
- if is_ssml(text):
- list_speak = create_clips_from_ssml(text)
- prev_speaker = None
- for i, clip in tqdm(enumerate(list_speak), total=len(list_speak)):
- selected_speaker = clip[0]
- # Add pause break between speakers
- if i > 0 and selected_speaker != prev_speaker:
- all_parts += [silencelong.copy()]
- prev_speaker = selected_speaker
- text = clip[1]
- text = saxutils.unescape(text)
- if selected_speaker == "None":
- selected_speaker = None
-
- print(f"\nGenerating Text ({i+1}/{len(list_speak)}) -> {selected_speaker} (Seed {currentseed}):`{text}`")
- complete_text += text
- with pytorch_seed.SavedRNG(currentseed):
- audio_array = generate_with_settings(text_prompt=text, voice_name=selected_speaker, semantic_temp=text_temp, coarse_temp=waveform_temp, eos_p=eos_prob)
- currentseed = torch.random.initial_seed()
- if len(list_speak) > 1:
- filename = create_filename(settings.output_folder_path, currentseed, "audioclip",".wav")
- save_wav(audio_array, filename)
- add_id3_tag(filename, text, selected_speaker, currentseed)
-
- all_parts += [audio_array]
- else:
- texts = split_and_recombine_text(text, settings.input_text_desired_length, settings.input_text_max_length)
- for i, text in tqdm(enumerate(texts), total=len(texts)):
- print(f"\nGenerating Text ({i+1}/{len(texts)}) -> {selected_speaker} (Seed {currentseed}):`{text}`")
- complete_text += text
- if quick_generation == True:
- with pytorch_seed.SavedRNG(currentseed):
- audio_array = generate_with_settings(text_prompt=text, voice_name=selected_speaker, semantic_temp=text_temp, coarse_temp=waveform_temp, eos_p=eos_prob)
- currentseed = torch.random.initial_seed()
- else:
- full_output = use_last_generation_as_history or save_last_generation
- if full_output:
- full_generation, audio_array = generate_with_settings(text_prompt=text, voice_name=voice_name, semantic_temp=text_temp, coarse_temp=waveform_temp, eos_p=eos_prob, output_full=True)
- else:
- audio_array = generate_with_settings(text_prompt=text, voice_name=voice_name, semantic_temp=text_temp, coarse_temp=waveform_temp, eos_p=eos_prob)
-
- # Noticed this in the HF Demo - convert to 16bit int -32767/32767 - most used audio format
- # audio_array = (audio_array * 32767).astype(np.int16)
-
- if len(texts) > 1:
- filename = create_filename(settings.output_folder_path, currentseed, "audioclip",".wav")
- save_wav(audio_array, filename)
- add_id3_tag(filename, text, selected_speaker, currentseed)
-
- if quick_generation == False and (save_last_generation == True or use_last_generation_as_history == True):
- # save to npz
- voice_name = create_filename(settings.output_folder_path, seed, "audioclip", ".npz")
- save_as_prompt(voice_name, full_generation)
- if use_last_generation_as_history:
- selected_speaker = voice_name
-
- all_parts += [audio_array]
- # Add short pause between sentences
- if text[-1] in "!?.\n" and i > 1:
- all_parts += [silenceshort.copy()]
-
- # save & play audio
- result = create_filename(settings.output_folder_path, currentseed, "final",".wav")
- save_wav(np.concatenate(all_parts), result)
- # write id3 tag with text truncated to 60 chars, as a precaution...
- add_id3_tag(result, complete_text, selected_speaker, currentseed)
-
- return result
-
-
-
-def save_wav(audio_array, filename):
- write_wav(filename, SAMPLE_RATE, audio_array)
-
-def save_voice(filename, semantic_prompt, coarse_prompt, fine_prompt):
- np.savez_compressed(
- filename,
- semantic_prompt=semantic_prompt,
- coarse_prompt=coarse_prompt,
- fine_prompt=fine_prompt
- )
-
-
-def on_quick_gen_changed(checkbox):
- if checkbox == False:
- return gr.CheckboxGroup.update(visible=True)
- return gr.CheckboxGroup.update(visible=False)
-
-def delete_output_files(checkbox_state):
- if checkbox_state:
- outputs_folder = os.path.join(os.getcwd(), settings.output_folder_path)
- if os.path.exists(outputs_folder):
- purgedir(outputs_folder)
- return False
-
-
-# https://stackoverflow.com/a/54494779
-def purgedir(parent):
- for root, dirs, files in os.walk(parent):
- for item in files:
- # Delete subordinate files
- filespec = os.path.join(root, item)
- os.unlink(filespec)
- for item in dirs:
- # Recursively perform this operation for subordinate directories
- purgedir(os.path.join(root, item))
-
-def convert_text_to_ssml(text, selected_speaker):
- return build_ssml(text, selected_speaker)
-
-
-def training_prepare(selected_step, num_text_generations, progress=gr.Progress(track_tqdm=True)):
- if selected_step == prepare_training_list[0]:
- prepare_semantics_from_text()
- else:
- prepare_wavs_from_semantics()
- return None
-
-
-def start_training(save_model_epoch, max_epochs, progress=gr.Progress(track_tqdm=True)):
- training_prepare_files("./training/data/", "./training/data/checkpoint/hubert_base_ls960.pt")
- train("./training/data/", save_model_epoch, max_epochs)
- return None
-
-
-
-def apply_settings(themes, input_server_name, input_server_port, input_server_public, input_desired_len, input_max_len, input_silence_break, input_silence_speaker):
- settings.selected_theme = themes
- settings.server_name = input_server_name
- settings.server_port = input_server_port
- settings.server_share = input_server_public
- settings.input_text_desired_length = input_desired_len
- settings.input_text_max_length = input_max_len
- settings.silence_sentence = input_silence_break
- settings.silence_speaker = input_silence_speaker
- settings.save()
-
-def restart():
- global restart_server
- restart_server = True
-
-
-def create_version_html():
- python_version = ".".join([str(x) for x in sys.version_info[0:3]])
- versions_html = f"""
-python: {python_version}
- •
-torch: {getattr(torch, '__long_version__',torch.__version__)}
- •
-gradio: {gr.__version__}
-"""
- return versions_html
-
-
-
-logger = logging.getLogger(__name__)
-APPTITLE = "Bark Voice Cloning UI"
-
-
-autolaunch = False
-
-if len(sys.argv) > 1:
- autolaunch = "-autolaunch" in sys.argv
-
-
-if torch.cuda.is_available() == False:
- os.environ['BARK_FORCE_CPU'] = 'True'
- logger.warning("No CUDA detected, fallback to CPU!")
-
-print(f'smallmodels={os.environ.get("SUNO_USE_SMALL_MODELS", False)}')
-print(f'enablemps={os.environ.get("SUNO_ENABLE_MPS", False)}')
-print(f'offloadcpu={os.environ.get("SUNO_OFFLOAD_CPU", False)}')
-print(f'forcecpu={os.environ.get("BARK_FORCE_CPU", False)}')
-print(f'autolaunch={autolaunch}\n\n')
-
-#print("Updating nltk\n")
-#nltk.download('punkt')
-
-print("Preloading Models\n")
-preload_models()
-
-available_themes = ["Default", "gradio/glass", "gradio/monochrome", "gradio/seafoam", "gradio/soft", "gstaff/xkcd", "freddyaboulton/dracula_revamped", "ysharma/steampunk"]
-tokenizer_language_list = ["de","en", "pl"]
-prepare_training_list = ["Step 1: Semantics from Text","Step 2: WAV from Semantics"]
-
-seed = -1
-server_name = settings.server_name
-if len(server_name) < 1:
- server_name = None
-server_port = settings.server_port
-if server_port <= 0:
- server_port = None
-global run_server
-global restart_server
-
-run_server = True
-
-while run_server:
- # Collect all existing speakers/voices in dir
- speakers_list = []
-
- for root, dirs, files in os.walk("./bark/assets/prompts"):
- for file in files:
- if file.endswith(".npz"):
- pathpart = root.replace("./bark/assets/prompts", "")
- name = os.path.join(pathpart, file[:-4])
- if name.startswith("/") or name.startswith("\\"):
- name = name[1:]
- speakers_list.append(name)
-
- speakers_list = sorted(speakers_list, key=lambda x: x.lower())
- speakers_list.insert(0, 'None')
-
- print(f'Launching {APPTITLE} Server')
-
- # Create Gradio Blocks
-
- with gr.Blocks(title=f"{APPTITLE}", mode=f"{APPTITLE}", theme=settings.selected_theme) as barkgui:
- gr.Markdown("# 🐶🎶⭐ - Bark真实拟声2.0，一键实现声音克隆 ")
- gr.Markdown("### 🤗 - 开启声音情感真实复刻的新纪元 🌊 ")
- gr.Markdown("### 🎡 - Based on [bark-gui](https://github.com/C0untFloyd/bark-gui) ")
- gr.Markdown(f""" You can duplicate and use it with a GPU:
- or open in [Colab](https://colab.research.google.com/github/KevinWang676/Bark-Voice-Cloning/blob/main/Bark_Voice_Cloning_UI.ipynb) for quick start 🌟
- """)
-
- with gr.Tab("🎙️ - Clone Voice"):
- with gr.Row():
- input_audio_filename = gr.Audio(label="Input audio.wav", source="upload", type="filepath")
- #transcription_text = gr.Textbox(label="Transcription Text", lines=1, placeholder="Enter Text of your Audio Sample here...")
- with gr.Row():
- with gr.Column():
- initialname = "/home/user/app/bark/assets/prompts/file"
- output_voice = gr.Textbox(label="Filename of trained Voice (do not change the initial name)", lines=1, placeholder=initialname, value=initialname, visible=False)
- with gr.Column():
- tokenizerlang = gr.Dropdown(tokenizer_language_list, label="Base Language Tokenizer", value=tokenizer_language_list[1], visible=False)
- with gr.Row():
- clone_voice_button = gr.Button("Create Voice", variant="primary")
- with gr.Row():
- dummy = gr.Text(label="Progress")
- npz_file = gr.File(label=".npz file")
- speakers_list.insert(0, npz_file) # add prompt
-
- with gr.Tab("🎵 - TTS"):
- with gr.Row():
- with gr.Column():
- placeholder = "Enter text here."
- input_text = gr.Textbox(label="Input Text", lines=4, placeholder=placeholder)
- convert_to_ssml_button = gr.Button("Convert Input Text to SSML")
- with gr.Column():
- seedcomponent = gr.Number(label="Seed (default -1 = Random)", precision=0, value=-1)
- batchcount = gr.Number(label="Batch count", precision=0, value=1)
-
- with gr.Row():
- with gr.Column():
- gr.Markdown("[Voice Prompt Library](https://suno-ai.notion.site/8b8e8749ed514b0cbf3f699013548683?v=bc67cff786b04b50b3ceb756fd05f68c)")
- speaker = gr.Dropdown(speakers_list, value=speakers_list[0], label="Voice (Choose “file” if you wanna use the custom voice)")
-
- with gr.Column():
- text_temp = gr.Slider(0.1, 1.0, value=0.6, label="Generation Temperature", info="1.0 more diverse, 0.1 more conservative")
- waveform_temp = gr.Slider(0.1, 1.0, value=0.7, label="Waveform temperature", info="1.0 more diverse, 0.1 more conservative")
-
- with gr.Row():
- with gr.Column():
- quick_gen_checkbox = gr.Checkbox(label="Quick Generation", value=True)
- settings_checkboxes = ["Use last generation as history", "Save generation as Voice"]
- complete_settings = gr.CheckboxGroup(choices=settings_checkboxes, value=settings_checkboxes, label="Detailed Generation Settings", type="value", interactive=True, visible=False)
- with gr.Column():
- eos_prob = gr.Slider(0.0, 0.5, value=0.05, label="End of sentence probability")
-
- with gr.Row():
- with gr.Column():
- tts_create_button = gr.Button("Generate", variant="primary")
- with gr.Column():
- hidden_checkbox = gr.Checkbox(visible=False)
- button_stop_generation = gr.Button("Stop generation")
- with gr.Row():
- output_audio = gr.Audio(label="Generated Audio", type="filepath")
-
- with gr.Tab("🔮 - Voice Conversion"):
- with gr.Row():
- swap_audio_filename = gr.Audio(label="Input audio.wav to swap voice", source="upload", type="filepath")
- with gr.Row():
- with gr.Column():
- swap_tokenizer_lang = gr.Dropdown(tokenizer_language_list, label="Base Language Tokenizer", value=tokenizer_language_list[1])
- swap_seed = gr.Number(label="Seed (default -1 = Random)", precision=0, value=-1)
- with gr.Column():
- speaker_swap = gr.Dropdown(speakers_list, value=speakers_list[0], label="Voice (Choose “file” if you wanna use the custom voice)")
- swap_batchcount = gr.Number(label="Batch count", precision=0, value=1)
- with gr.Row():
- swap_voice_button = gr.Button("Generate", variant="primary")
- with gr.Row():
- output_swap = gr.Audio(label="Generated Audio", type="filepath")
-
-
- quick_gen_checkbox.change(fn=on_quick_gen_changed, inputs=quick_gen_checkbox, outputs=complete_settings)
- convert_to_ssml_button.click(convert_text_to_ssml, inputs=[input_text, speaker],outputs=input_text)
- gen_click = tts_create_button.click(generate_text_to_speech, inputs=[input_text, speaker, text_temp, waveform_temp, eos_prob, quick_gen_checkbox, complete_settings, seedcomponent, batchcount],outputs=output_audio)
- button_stop_generation.click(fn=None, inputs=None, outputs=None, cancels=[gen_click])
-
-
-
- swap_voice_button.click(swap_voice_from_audio, inputs=[swap_audio_filename, speaker_swap, swap_tokenizer_lang, swap_seed, swap_batchcount], outputs=output_swap)
- clone_voice_button.click(clone_voice, inputs=[input_audio_filename, output_voice], outputs=[dummy, npz_file])
-
-
- restart_server = False
- try:
- barkgui.queue().launch(show_error=True)
- except:
- restart_server = True
- run_server = False
- try:
- while restart_server == False:
- time.sleep(1.0)
- except (KeyboardInterrupt, OSError):
- print("Keyboard interruption in main thread... closing server.")
- run_server = False
- barkgui.close()
-
-
-
-
diff --git a/spaces/kevinwang676/Bert-VITS2/monotonic_align/core.c b/spaces/kevinwang676/Bert-VITS2/monotonic_align/core.c
deleted file mode 100644
index 5f8af54d32474f821e9d1f4d2679d78128722596..0000000000000000000000000000000000000000
--- a/spaces/kevinwang676/Bert-VITS2/monotonic_align/core.c
+++ /dev/null
@@ -1,26530 +0,0 @@
-/* Generated by Cython 3.0.0 */
-
-/* BEGIN: Cython Metadata
-{
- "distutils": {
- "name": "monotonic_align.core",
- "sources": [
- "core.pyx"
- ]
- },
- "module_name": "monotonic_align.core"
-}
-END: Cython Metadata */
-
-#ifndef PY_SSIZE_T_CLEAN
-#define PY_SSIZE_T_CLEAN
-#endif /* PY_SSIZE_T_CLEAN */
-#if defined(CYTHON_LIMITED_API) && 0
- #ifndef Py_LIMITED_API
- #if CYTHON_LIMITED_API+0 > 0x03030000
- #define Py_LIMITED_API CYTHON_LIMITED_API
- #else
- #define Py_LIMITED_API 0x03030000
- #endif
- #endif
-#endif
-
-#include "Python.h"
-#ifndef Py_PYTHON_H
- #error Python headers needed to compile C extensions, please install development version of Python.
-#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
- #error Cython requires Python 2.7+ or Python 3.3+.
-#else
-#define CYTHON_ABI "3_0_0"
-#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI
-#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "."
-#define CYTHON_HEX_VERSION 0x030000F0
-#define CYTHON_FUTURE_DIVISION 1
-#include
-#ifndef offsetof
- #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
-#endif
-#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS)
- #ifndef __stdcall
- #define __stdcall
- #endif
- #ifndef __cdecl
- #define __cdecl
- #endif
- #ifndef __fastcall
- #define __fastcall
- #endif
-#endif
-#ifndef DL_IMPORT
- #define DL_IMPORT(t) t
-#endif
-#ifndef DL_EXPORT
- #define DL_EXPORT(t) t
-#endif
-#define __PYX_COMMA ,
-#ifndef HAVE_LONG_LONG
- #define HAVE_LONG_LONG
-#endif
-#ifndef PY_LONG_LONG
- #define PY_LONG_LONG LONG_LONG
-#endif
-#ifndef Py_HUGE_VAL
- #define Py_HUGE_VAL HUGE_VAL
-#endif
-#if defined(GRAALVM_PYTHON)
- /* For very preliminary testing purposes. Most variables are set the same as PyPy.
- The existence of this section does not imply that anything works or is even tested */
- #define CYTHON_COMPILING_IN_PYPY 0
- #define CYTHON_COMPILING_IN_CPYTHON 0
- #define CYTHON_COMPILING_IN_LIMITED_API 0
- #define CYTHON_COMPILING_IN_GRAAL 1
- #define CYTHON_COMPILING_IN_NOGIL 0
- #undef CYTHON_USE_TYPE_SLOTS
- #define CYTHON_USE_TYPE_SLOTS 0
- #undef CYTHON_USE_TYPE_SPECS
- #define CYTHON_USE_TYPE_SPECS 0
- #undef CYTHON_USE_PYTYPE_LOOKUP
- #define CYTHON_USE_PYTYPE_LOOKUP 0
- #if PY_VERSION_HEX < 0x03050000
- #undef CYTHON_USE_ASYNC_SLOTS
- #define CYTHON_USE_ASYNC_SLOTS 0
- #elif !defined(CYTHON_USE_ASYNC_SLOTS)
- #define CYTHON_USE_ASYNC_SLOTS 1
- #endif
- #undef CYTHON_USE_PYLIST_INTERNALS
- #define CYTHON_USE_PYLIST_INTERNALS 0
- #undef CYTHON_USE_UNICODE_INTERNALS
- #define CYTHON_USE_UNICODE_INTERNALS 0
- #undef CYTHON_USE_UNICODE_WRITER
- #define CYTHON_USE_UNICODE_WRITER 0
- #undef CYTHON_USE_PYLONG_INTERNALS
- #define CYTHON_USE_PYLONG_INTERNALS 0
- #undef CYTHON_AVOID_BORROWED_REFS
- #define CYTHON_AVOID_BORROWED_REFS 1
- #undef CYTHON_ASSUME_SAFE_MACROS
- #define CYTHON_ASSUME_SAFE_MACROS 0
- #undef CYTHON_UNPACK_METHODS
- #define CYTHON_UNPACK_METHODS 0
- #undef CYTHON_FAST_THREAD_STATE
- #define CYTHON_FAST_THREAD_STATE 0
- #undef CYTHON_FAST_GIL
- #define CYTHON_FAST_GIL 0
- #undef CYTHON_METH_FASTCALL
- #define CYTHON_METH_FASTCALL 0
- #undef CYTHON_FAST_PYCALL
- #define CYTHON_FAST_PYCALL 0
- #ifndef CYTHON_PEP487_INIT_SUBCLASS
- #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
- #endif
- #undef CYTHON_PEP489_MULTI_PHASE_INIT
- #define CYTHON_PEP489_MULTI_PHASE_INIT 1
- #undef CYTHON_USE_MODULE_STATE
- #define CYTHON_USE_MODULE_STATE 0
- #undef CYTHON_USE_TP_FINALIZE
- #define CYTHON_USE_TP_FINALIZE 0
- #undef CYTHON_USE_DICT_VERSIONS
- #define CYTHON_USE_DICT_VERSIONS 0
- #undef CYTHON_USE_EXC_INFO_STACK
- #define CYTHON_USE_EXC_INFO_STACK 0
- #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
- #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
- #endif
-#elif defined(PYPY_VERSION)
- #define CYTHON_COMPILING_IN_PYPY 1
- #define CYTHON_COMPILING_IN_CPYTHON 0
- #define CYTHON_COMPILING_IN_LIMITED_API 0
- #define CYTHON_COMPILING_IN_GRAAL 0
- #define CYTHON_COMPILING_IN_NOGIL 0
- #undef CYTHON_USE_TYPE_SLOTS
- #define CYTHON_USE_TYPE_SLOTS 0
- #undef CYTHON_USE_TYPE_SPECS
- #define CYTHON_USE_TYPE_SPECS 0
- #undef CYTHON_USE_PYTYPE_LOOKUP
- #define CYTHON_USE_PYTYPE_LOOKUP 0
- #if PY_VERSION_HEX < 0x03050000
- #undef CYTHON_USE_ASYNC_SLOTS
- #define CYTHON_USE_ASYNC_SLOTS 0
- #elif !defined(CYTHON_USE_ASYNC_SLOTS)
- #define CYTHON_USE_ASYNC_SLOTS 1
- #endif
- #undef CYTHON_USE_PYLIST_INTERNALS
- #define CYTHON_USE_PYLIST_INTERNALS 0
- #undef CYTHON_USE_UNICODE_INTERNALS
- #define CYTHON_USE_UNICODE_INTERNALS 0
- #undef CYTHON_USE_UNICODE_WRITER
- #define CYTHON_USE_UNICODE_WRITER 0
- #undef CYTHON_USE_PYLONG_INTERNALS
- #define CYTHON_USE_PYLONG_INTERNALS 0
- #undef CYTHON_AVOID_BORROWED_REFS
- #define CYTHON_AVOID_BORROWED_REFS 1
- #undef CYTHON_ASSUME_SAFE_MACROS
- #define CYTHON_ASSUME_SAFE_MACROS 0
- #undef CYTHON_UNPACK_METHODS
- #define CYTHON_UNPACK_METHODS 0
- #undef CYTHON_FAST_THREAD_STATE
- #define CYTHON_FAST_THREAD_STATE 0
- #undef CYTHON_FAST_GIL
- #define CYTHON_FAST_GIL 0
- #undef CYTHON_METH_FASTCALL
- #define CYTHON_METH_FASTCALL 0
- #undef CYTHON_FAST_PYCALL
- #define CYTHON_FAST_PYCALL 0
- #ifndef CYTHON_PEP487_INIT_SUBCLASS
- #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
- #endif
- #if PY_VERSION_HEX < 0x03090000
- #undef CYTHON_PEP489_MULTI_PHASE_INIT
- #define CYTHON_PEP489_MULTI_PHASE_INIT 0
- #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
- #define CYTHON_PEP489_MULTI_PHASE_INIT 1
- #endif
- #undef CYTHON_USE_MODULE_STATE
- #define CYTHON_USE_MODULE_STATE 0
- #undef CYTHON_USE_TP_FINALIZE
- #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00)
- #undef CYTHON_USE_DICT_VERSIONS
- #define CYTHON_USE_DICT_VERSIONS 0
- #undef CYTHON_USE_EXC_INFO_STACK
- #define CYTHON_USE_EXC_INFO_STACK 0
- #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
- #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
- #endif
-#elif defined(CYTHON_LIMITED_API)
- #define CYTHON_COMPILING_IN_PYPY 0
- #define CYTHON_COMPILING_IN_CPYTHON 0
- #define CYTHON_COMPILING_IN_LIMITED_API 1
- #define CYTHON_COMPILING_IN_GRAAL 0
- #define CYTHON_COMPILING_IN_NOGIL 0
- #undef CYTHON_CLINE_IN_TRACEBACK
- #define CYTHON_CLINE_IN_TRACEBACK 0
- #undef CYTHON_USE_TYPE_SLOTS
- #define CYTHON_USE_TYPE_SLOTS 0
- #undef CYTHON_USE_TYPE_SPECS
- #define CYTHON_USE_TYPE_SPECS 1
- #undef CYTHON_USE_PYTYPE_LOOKUP
- #define CYTHON_USE_PYTYPE_LOOKUP 0
- #undef CYTHON_USE_ASYNC_SLOTS
- #define CYTHON_USE_ASYNC_SLOTS 0
- #undef CYTHON_USE_PYLIST_INTERNALS
- #define CYTHON_USE_PYLIST_INTERNALS 0
- #undef CYTHON_USE_UNICODE_INTERNALS
- #define CYTHON_USE_UNICODE_INTERNALS 0
- #ifndef CYTHON_USE_UNICODE_WRITER
- #define CYTHON_USE_UNICODE_WRITER 0
- #endif
- #undef CYTHON_USE_PYLONG_INTERNALS
- #define CYTHON_USE_PYLONG_INTERNALS 0
- #ifndef CYTHON_AVOID_BORROWED_REFS
- #define CYTHON_AVOID_BORROWED_REFS 0
- #endif
- #undef CYTHON_ASSUME_SAFE_MACROS
- #define CYTHON_ASSUME_SAFE_MACROS 0
- #undef CYTHON_UNPACK_METHODS
- #define CYTHON_UNPACK_METHODS 0
- #undef CYTHON_FAST_THREAD_STATE
- #define CYTHON_FAST_THREAD_STATE 0
- #undef CYTHON_FAST_GIL
- #define CYTHON_FAST_GIL 0
- #undef CYTHON_METH_FASTCALL
- #define CYTHON_METH_FASTCALL 0
- #undef CYTHON_FAST_PYCALL
- #define CYTHON_FAST_PYCALL 0
- #ifndef CYTHON_PEP487_INIT_SUBCLASS
- #define CYTHON_PEP487_INIT_SUBCLASS 1
- #endif
- #undef CYTHON_PEP489_MULTI_PHASE_INIT
- #define CYTHON_PEP489_MULTI_PHASE_INIT 0
- #undef CYTHON_USE_MODULE_STATE
- #define CYTHON_USE_MODULE_STATE 1
- #ifndef CYTHON_USE_TP_FINALIZE
- #define CYTHON_USE_TP_FINALIZE 1
- #endif
- #undef CYTHON_USE_DICT_VERSIONS
- #define CYTHON_USE_DICT_VERSIONS 0
- #undef CYTHON_USE_EXC_INFO_STACK
- #define CYTHON_USE_EXC_INFO_STACK 0
- #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
- #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
- #endif
-#elif defined(PY_NOGIL)
- #define CYTHON_COMPILING_IN_PYPY 0
- #define CYTHON_COMPILING_IN_CPYTHON 0
- #define CYTHON_COMPILING_IN_LIMITED_API 0
- #define CYTHON_COMPILING_IN_GRAAL 0
- #define CYTHON_COMPILING_IN_NOGIL 1
- #ifndef CYTHON_USE_TYPE_SLOTS
- #define CYTHON_USE_TYPE_SLOTS 1
- #endif
- #undef CYTHON_USE_PYTYPE_LOOKUP
- #define CYTHON_USE_PYTYPE_LOOKUP 0
- #ifndef CYTHON_USE_ASYNC_SLOTS
- #define CYTHON_USE_ASYNC_SLOTS 1
- #endif
- #undef CYTHON_USE_PYLIST_INTERNALS
- #define CYTHON_USE_PYLIST_INTERNALS 0
- #ifndef CYTHON_USE_UNICODE_INTERNALS
- #define CYTHON_USE_UNICODE_INTERNALS 1
- #endif
- #undef CYTHON_USE_UNICODE_WRITER
- #define CYTHON_USE_UNICODE_WRITER 0
- #undef CYTHON_USE_PYLONG_INTERNALS
- #define CYTHON_USE_PYLONG_INTERNALS 0
- #ifndef CYTHON_AVOID_BORROWED_REFS
- #define CYTHON_AVOID_BORROWED_REFS 0
- #endif
- #ifndef CYTHON_ASSUME_SAFE_MACROS
- #define CYTHON_ASSUME_SAFE_MACROS 1
- #endif
- #ifndef CYTHON_UNPACK_METHODS
- #define CYTHON_UNPACK_METHODS 1
- #endif
- #undef CYTHON_FAST_THREAD_STATE
- #define CYTHON_FAST_THREAD_STATE 0
- #undef CYTHON_FAST_PYCALL
- #define CYTHON_FAST_PYCALL 0
- #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
- #define CYTHON_PEP489_MULTI_PHASE_INIT 1
- #endif
- #ifndef CYTHON_USE_TP_FINALIZE
- #define CYTHON_USE_TP_FINALIZE 1
- #endif
- #undef CYTHON_USE_DICT_VERSIONS
- #define CYTHON_USE_DICT_VERSIONS 0
- #undef CYTHON_USE_EXC_INFO_STACK
- #define CYTHON_USE_EXC_INFO_STACK 0
-#else
- #define CYTHON_COMPILING_IN_PYPY 0
- #define CYTHON_COMPILING_IN_CPYTHON 1
- #define CYTHON_COMPILING_IN_LIMITED_API 0
- #define CYTHON_COMPILING_IN_GRAAL 0
- #define CYTHON_COMPILING_IN_NOGIL 0
- #ifndef CYTHON_USE_TYPE_SLOTS
- #define CYTHON_USE_TYPE_SLOTS 1
- #endif
- #ifndef CYTHON_USE_TYPE_SPECS
- #define CYTHON_USE_TYPE_SPECS 0
- #endif
- #ifndef CYTHON_USE_PYTYPE_LOOKUP
- #define CYTHON_USE_PYTYPE_LOOKUP 1
- #endif
- #if PY_MAJOR_VERSION < 3
- #undef CYTHON_USE_ASYNC_SLOTS
- #define CYTHON_USE_ASYNC_SLOTS 0
- #elif !defined(CYTHON_USE_ASYNC_SLOTS)
- #define CYTHON_USE_ASYNC_SLOTS 1
- #endif
- #ifndef CYTHON_USE_PYLONG_INTERNALS
- #define CYTHON_USE_PYLONG_INTERNALS 1
- #endif
- #ifndef CYTHON_USE_PYLIST_INTERNALS
- #define CYTHON_USE_PYLIST_INTERNALS 1
- #endif
- #ifndef CYTHON_USE_UNICODE_INTERNALS
- #define CYTHON_USE_UNICODE_INTERNALS 1
- #endif
- #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2
- #undef CYTHON_USE_UNICODE_WRITER
- #define CYTHON_USE_UNICODE_WRITER 0
- #elif !defined(CYTHON_USE_UNICODE_WRITER)
- #define CYTHON_USE_UNICODE_WRITER 1
- #endif
- #ifndef CYTHON_AVOID_BORROWED_REFS
- #define CYTHON_AVOID_BORROWED_REFS 0
- #endif
- #ifndef CYTHON_ASSUME_SAFE_MACROS
- #define CYTHON_ASSUME_SAFE_MACROS 1
- #endif
- #ifndef CYTHON_UNPACK_METHODS
- #define CYTHON_UNPACK_METHODS 1
- #endif
- #ifndef CYTHON_FAST_THREAD_STATE
- #define CYTHON_FAST_THREAD_STATE 1
- #endif
- #ifndef CYTHON_FAST_GIL
- #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6)
- #endif
- #ifndef CYTHON_METH_FASTCALL
- #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1)
- #endif
- #ifndef CYTHON_FAST_PYCALL
- #define CYTHON_FAST_PYCALL 1
- #endif
- #ifndef CYTHON_PEP487_INIT_SUBCLASS
- #define CYTHON_PEP487_INIT_SUBCLASS 1
- #endif
- #if PY_VERSION_HEX < 0x03050000
- #undef CYTHON_PEP489_MULTI_PHASE_INIT
- #define CYTHON_PEP489_MULTI_PHASE_INIT 0
- #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
- #define CYTHON_PEP489_MULTI_PHASE_INIT 1
- #endif
- #ifndef CYTHON_USE_MODULE_STATE
- #define CYTHON_USE_MODULE_STATE 0
- #endif
- #if PY_VERSION_HEX < 0x030400a1
- #undef CYTHON_USE_TP_FINALIZE
- #define CYTHON_USE_TP_FINALIZE 0
- #elif !defined(CYTHON_USE_TP_FINALIZE)
- #define CYTHON_USE_TP_FINALIZE 1
- #endif
- #if PY_VERSION_HEX < 0x030600B1
- #undef CYTHON_USE_DICT_VERSIONS
- #define CYTHON_USE_DICT_VERSIONS 0
- #elif !defined(CYTHON_USE_DICT_VERSIONS)
- #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5)
- #endif
- #if PY_VERSION_HEX < 0x030700A3
- #undef CYTHON_USE_EXC_INFO_STACK
- #define CYTHON_USE_EXC_INFO_STACK 0
- #elif !defined(CYTHON_USE_EXC_INFO_STACK)
- #define CYTHON_USE_EXC_INFO_STACK 1
- #endif
- #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
- #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
- #endif
-#endif
-#if !defined(CYTHON_FAST_PYCCALL)
-#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
-#endif
-#if !defined(CYTHON_VECTORCALL)
-#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1)
-#endif
-#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1)
-#if CYTHON_USE_PYLONG_INTERNALS
- #if PY_MAJOR_VERSION < 3
- #include "longintrepr.h"
- #endif
- #undef SHIFT
- #undef BASE
- #undef MASK
- #ifdef SIZEOF_VOID_P
- enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) };
- #endif
-#endif
-#ifndef __has_attribute
- #define __has_attribute(x) 0
-#endif
-#ifndef __has_cpp_attribute
- #define __has_cpp_attribute(x) 0
-#endif
-#ifndef CYTHON_RESTRICT
- #if defined(__GNUC__)
- #define CYTHON_RESTRICT __restrict__
- #elif defined(_MSC_VER) && _MSC_VER >= 1400
- #define CYTHON_RESTRICT __restrict
- #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
- #define CYTHON_RESTRICT restrict
- #else
- #define CYTHON_RESTRICT
- #endif
-#endif
-#ifndef CYTHON_UNUSED
- #if defined(__cplusplus)
- /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17
- * but leads to warnings with -pedantic, since it is a C++17 feature */
- #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
- #if __has_cpp_attribute(maybe_unused)
- #define CYTHON_UNUSED [[maybe_unused]]
- #endif
- #endif
- #endif
-#endif
-#ifndef CYTHON_UNUSED
-# if defined(__GNUC__)
-# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
-# define CYTHON_UNUSED __attribute__ ((__unused__))
-# else
-# define CYTHON_UNUSED
-# endif
-# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
-# define CYTHON_UNUSED __attribute__ ((__unused__))
-# else
-# define CYTHON_UNUSED
-# endif
-#endif
-#ifndef CYTHON_UNUSED_VAR
-# if defined(__cplusplus)
- template void CYTHON_UNUSED_VAR( const T& ) { }
-# else
-# define CYTHON_UNUSED_VAR(x) (void)(x)
-# endif
-#endif
-#ifndef CYTHON_MAYBE_UNUSED_VAR
- #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x)
-#endif
-#ifndef CYTHON_NCP_UNUSED
-# if CYTHON_COMPILING_IN_CPYTHON
-# define CYTHON_NCP_UNUSED
-# else
-# define CYTHON_NCP_UNUSED CYTHON_UNUSED
-# endif
-#endif
-#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
-#ifdef _MSC_VER
- #ifndef _MSC_STDINT_H_
- #if _MSC_VER < 1300
- typedef unsigned char uint8_t;
- typedef unsigned short uint16_t;
- typedef unsigned int uint32_t;
- #else
- typedef unsigned __int8 uint8_t;
- typedef unsigned __int16 uint16_t;
- typedef unsigned __int32 uint32_t;
- #endif
- #endif
- #if _MSC_VER < 1300
- #ifdef _WIN64
- typedef unsigned long long __pyx_uintptr_t;
- #else
- typedef unsigned int __pyx_uintptr_t;
- #endif
- #else
- #ifdef _WIN64
- typedef unsigned __int64 __pyx_uintptr_t;
- #else
- typedef unsigned __int32 __pyx_uintptr_t;
- #endif
- #endif
-#else
- #include
- typedef uintptr_t __pyx_uintptr_t;
-#endif
-#ifndef CYTHON_FALLTHROUGH
- #if defined(__cplusplus)
- /* for clang __has_cpp_attribute(fallthrough) is true even before C++17
- * but leads to warnings with -pedantic, since it is a C++17 feature */
- #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
- #if __has_cpp_attribute(fallthrough)
- #define CYTHON_FALLTHROUGH [[fallthrough]]
- #endif
- #endif
- #ifndef CYTHON_FALLTHROUGH
- #if __has_cpp_attribute(clang::fallthrough)
- #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
- #elif __has_cpp_attribute(gnu::fallthrough)
- #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
- #endif
- #endif
- #endif
- #ifndef CYTHON_FALLTHROUGH
- #if __has_attribute(fallthrough)
- #define CYTHON_FALLTHROUGH __attribute__((fallthrough))
- #else
- #define CYTHON_FALLTHROUGH
- #endif
- #endif
- #if defined(__clang__) && defined(__apple_build_version__)
- #if __apple_build_version__ < 7000000
- #undef CYTHON_FALLTHROUGH
- #define CYTHON_FALLTHROUGH
- #endif
- #endif
-#endif
-#ifdef __cplusplus
- template
- struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);};
- #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value)
-#else
- #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0)
-#endif
-#if CYTHON_COMPILING_IN_PYPY == 1
- #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000)
-#else
- #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000)
-#endif
-#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer))
-
-#ifndef CYTHON_INLINE
- #if defined(__clang__)
- #define CYTHON_INLINE __inline__ __attribute__ ((__unused__))
- #elif defined(__GNUC__)
- #define CYTHON_INLINE __inline__
- #elif defined(_MSC_VER)
- #define CYTHON_INLINE __inline
- #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
- #define CYTHON_INLINE inline
- #else
- #define CYTHON_INLINE
- #endif
-#endif
-
-#define __PYX_BUILD_PY_SSIZE_T "n"
-#define CYTHON_FORMAT_SSIZE_T "z"
-#if PY_MAJOR_VERSION < 3
- #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
- #define __Pyx_DefaultClassType PyClass_Type
- #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
- PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
-#else
- #define __Pyx_BUILTIN_MODULE_NAME "builtins"
- #define __Pyx_DefaultClassType PyType_Type
-#if PY_VERSION_HEX >= 0x030B00A1
- static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
- PyObject *code, PyObject *c, PyObject* n, PyObject *v,
- PyObject *fv, PyObject *cell, PyObject* fn,
- PyObject *name, int fline, PyObject *lnos) {
- PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL;
- PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *empty=NULL;
- const char *fn_cstr=NULL;
- const char *name_cstr=NULL;
- PyCodeObject *co=NULL, *result=NULL;
- PyObject *type, *value, *traceback;
- PyErr_Fetch(&type, &value, &traceback);
- if (!(kwds=PyDict_New())) goto end;
- if (!(argcount=PyLong_FromLong(a))) goto end;
- if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end;
- if (!(posonlyargcount=PyLong_FromLong(p))) goto end;
- if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end;
- if (!(kwonlyargcount=PyLong_FromLong(k))) goto end;
- if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end;
- if (!(nlocals=PyLong_FromLong(l))) goto end;
- if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end;
- if (!(stacksize=PyLong_FromLong(s))) goto end;
- if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end;
- if (!(flags=PyLong_FromLong(f))) goto end;
- if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end;
- if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end;
- if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end;
- if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end;
- if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end;
- if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end;
- if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end;
- if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end;
- if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end;
- if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end;
- if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end;
- if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto end;
- if (!(empty = PyTuple_New(0))) goto end;
- result = (PyCodeObject*) PyObject_Call(replace, empty, kwds);
- end:
- Py_XDECREF((PyObject*) co);
- Py_XDECREF(kwds);
- Py_XDECREF(argcount);
- Py_XDECREF(posonlyargcount);
- Py_XDECREF(kwonlyargcount);
- Py_XDECREF(nlocals);
- Py_XDECREF(stacksize);
- Py_XDECREF(replace);
- Py_XDECREF(empty);
- if (type) {
- PyErr_Restore(type, value, traceback);
- }
- return result;
- }
-#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY
- #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
- PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
-#else
- #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
- PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
-#endif
-#endif
-#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE)
- #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type)
-#else
- #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type))
-#endif
-#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is)
- #define __Pyx_Py_Is(x, y) Py_Is(x, y)
-#else
- #define __Pyx_Py_Is(x, y) ((x) == (y))
-#endif
-#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone)
- #define __Pyx_Py_IsNone(ob) Py_IsNone(ob)
-#else
- #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None)
-#endif
-#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue)
- #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob)
-#else
- #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True)
-#endif
-#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse)
- #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob)
-#else
- #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False)
-#endif
-#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj))
-#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY
- #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o)
-#else
- #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o)
-#endif
-#ifndef CO_COROUTINE
- #define CO_COROUTINE 0x80
-#endif
-#ifndef CO_ASYNC_GENERATOR
- #define CO_ASYNC_GENERATOR 0x200
-#endif
-#ifndef Py_TPFLAGS_CHECKTYPES
- #define Py_TPFLAGS_CHECKTYPES 0
-#endif
-#ifndef Py_TPFLAGS_HAVE_INDEX
- #define Py_TPFLAGS_HAVE_INDEX 0
-#endif
-#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
- #define Py_TPFLAGS_HAVE_NEWBUFFER 0
-#endif
-#ifndef Py_TPFLAGS_HAVE_FINALIZE
- #define Py_TPFLAGS_HAVE_FINALIZE 0
-#endif
-#ifndef Py_TPFLAGS_SEQUENCE
- #define Py_TPFLAGS_SEQUENCE 0
-#endif
-#ifndef Py_TPFLAGS_MAPPING
- #define Py_TPFLAGS_MAPPING 0
-#endif
-#ifndef METH_STACKLESS
- #define METH_STACKLESS 0
-#endif
-#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL)
- #ifndef METH_FASTCALL
- #define METH_FASTCALL 0x80
- #endif
- typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs);
- typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
- Py_ssize_t nargs, PyObject *kwnames);
-#else
- #define __Pyx_PyCFunctionFast _PyCFunctionFast
- #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
-#endif
-#if CYTHON_METH_FASTCALL
- #define __Pyx_METH_FASTCALL METH_FASTCALL
- #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast
- #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords
-#else
- #define __Pyx_METH_FASTCALL METH_VARARGS
- #define __Pyx_PyCFunction_FastCall PyCFunction
- #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords
-#endif
-#if CYTHON_VECTORCALL
- #define __pyx_vectorcallfunc vectorcallfunc
- #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET
- #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n))
-#elif CYTHON_BACKPORT_VECTORCALL
- typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args,
- size_t nargsf, PyObject *kwnames);
- #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1))
- #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET))
-#else
- #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0
- #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n))
-#endif
-#if PY_VERSION_HEX < 0x030900B1
- #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b))
- typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *);
-#else
- #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b)
- #define __Pyx_PyCMethod PyCMethod
-#endif
-#ifndef METH_METHOD
- #define METH_METHOD 0x200
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
- #define PyObject_Malloc(s) PyMem_Malloc(s)
- #define PyObject_Free(p) PyMem_Free(p)
- #define PyObject_Realloc(p) PyMem_Realloc(p)
-#endif
-#if CYTHON_COMPILING_IN_LIMITED_API
- #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0)
- #define __Pyx_PyFrame_SetLineNumber(frame, lineno)
-#else
- #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0)
- #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno)
-#endif
-#if CYTHON_COMPILING_IN_LIMITED_API
- #define __Pyx_PyThreadState_Current PyThreadState_Get()
-#elif !CYTHON_FAST_THREAD_STATE
- #define __Pyx_PyThreadState_Current PyThreadState_GET()
-#elif PY_VERSION_HEX >= 0x03060000
- #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
-#elif PY_VERSION_HEX >= 0x03000000
- #define __Pyx_PyThreadState_Current PyThreadState_GET()
-#else
- #define __Pyx_PyThreadState_Current _PyThreadState_Current
-#endif
-#if CYTHON_COMPILING_IN_LIMITED_API
-static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op)
-{
- void *result;
- result = PyModule_GetState(op);
- if (!result)
- Py_FatalError("Couldn't find the module state");
- return result;
-}
-#endif
-#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype)
-#if CYTHON_COMPILING_IN_LIMITED_API
- #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name))
-#else
- #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name)
-#endif
-#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
-#include "pythread.h"
-#define Py_tss_NEEDS_INIT 0
-typedef int Py_tss_t;
-static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) {
- *key = PyThread_create_key();
- return 0;
-}
-static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) {
- Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t));
- *key = Py_tss_NEEDS_INIT;
- return key;
-}
-static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) {
- PyObject_Free(key);
-}
-static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) {
- return *key != Py_tss_NEEDS_INIT;
-}
-static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) {
- PyThread_delete_key(*key);
- *key = Py_tss_NEEDS_INIT;
-}
-static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) {
- return PyThread_set_key_value(*key, value);
-}
-static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
- return PyThread_get_key_value(*key);
-}
-#endif
-#if PY_MAJOR_VERSION < 3
- #if CYTHON_COMPILING_IN_PYPY
- #if PYPY_VERSION_NUM < 0x07030600
- #if defined(__cplusplus) && __cplusplus >= 201402L
- [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]]
- #elif defined(__GNUC__) || defined(__clang__)
- __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")))
- #elif defined(_MSC_VER)
- __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))
- #endif
- static CYTHON_INLINE int PyGILState_Check(void) {
- return 0;
- }
- #else // PYPY_VERSION_NUM < 0x07030600
- #endif // PYPY_VERSION_NUM < 0x07030600
- #else
- static CYTHON_INLINE int PyGILState_Check(void) {
- PyThreadState * tstate = _PyThreadState_Current;
- return tstate && (tstate == PyGILState_GetThisThreadState());
- }
- #endif
-#endif
-#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
-#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
-#else
-#define __Pyx_PyDict_NewPresized(n) PyDict_New()
-#endif
-#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION
- #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y)
- #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y)
-#else
- #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y)
- #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y)
-#endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && CYTHON_USE_UNICODE_INTERNALS
-#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
-static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) {
- PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name);
- if (res == NULL) PyErr_Clear();
- return res;
-}
-#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000)
-#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError
-#define __Pyx_PyDict_GetItemStr PyDict_GetItem
-#else
-static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) {
-#if CYTHON_COMPILING_IN_PYPY
- return PyDict_GetItem(dict, name);
-#else
- PyDictEntry *ep;
- PyDictObject *mp = (PyDictObject*) dict;
- long hash = ((PyStringObject *) name)->ob_shash;
- assert(hash != -1);
- ep = (mp->ma_lookup)(mp, name, hash);
- if (ep == NULL) {
- return NULL;
- }
- return ep->me_value;
-#endif
-}
-#define __Pyx_PyDict_GetItemStr PyDict_GetItem
-#endif
-#if CYTHON_USE_TYPE_SLOTS
- #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags)
- #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0)
- #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext)
-#else
- #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp))
- #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature)
- #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next
-#endif
-#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000
-#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\
- PyTypeObject *type = Py_TYPE(obj);\
- assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\
- PyObject_GC_Del(obj);\
- Py_DECREF(type);\
-}
-#else
-#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj)
-#endif
-#if CYTHON_COMPILING_IN_LIMITED_API
- #define CYTHON_PEP393_ENABLED 1
- #define __Pyx_PyUnicode_READY(op) (0)
- #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u)
- #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i)
- #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U)
- #define __Pyx_PyUnicode_KIND(u) ((void)u, (0))
- #define __Pyx_PyUnicode_DATA(u) ((void*)u)
- #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i))
- #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u))
-#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
- #define CYTHON_PEP393_ENABLED 1
- #if PY_VERSION_HEX >= 0x030C0000
- #define __Pyx_PyUnicode_READY(op) (0)
- #else
- #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\
- 0 : _PyUnicode_Ready((PyObject *)(op)))
- #endif
- #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u)
- #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
- #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u)
- #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u))
- #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u)
- #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i)
- #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, (Py_UCS4) ch)
- #if PY_VERSION_HEX >= 0x030C0000
- #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u))
- #else
- #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
- #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
- #else
- #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
- #endif
- #endif
-#else
- #define CYTHON_PEP393_ENABLED 0
- #define PyUnicode_1BYTE_KIND 1
- #define PyUnicode_2BYTE_KIND 2
- #define PyUnicode_4BYTE_KIND 4
- #define __Pyx_PyUnicode_READY(op) (0)
- #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u)
- #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
- #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U)
- #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE))
- #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u))
- #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
- #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch)
- #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u))
-#endif
-#if CYTHON_COMPILING_IN_PYPY
- #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b)
- #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b)
-#else
- #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b)
- #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
- PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
-#endif
-#if CYTHON_COMPILING_IN_PYPY
- #if !defined(PyUnicode_DecodeUnicodeEscape)
- #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors)
- #endif
- #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500)
- #undef PyUnicode_Contains
- #define PyUnicode_Contains(u, s) PySequence_Contains(u, s)
- #endif
- #if !defined(PyByteArray_Check)
- #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type)
- #endif
- #if !defined(PyObject_Format)
- #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt)
- #endif
-#endif
-#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
-#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
-#if PY_MAJOR_VERSION >= 3
- #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b)
-#else
- #define __Pyx_PyString_Format(a, b) PyString_Format(a, b)
-#endif
-#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
- #define PyObject_ASCII(o) PyObject_Repr(o)
-#endif
-#if PY_MAJOR_VERSION >= 3
- #define PyBaseString_Type PyUnicode_Type
- #define PyStringObject PyUnicodeObject
- #define PyString_Type PyUnicode_Type
- #define PyString_Check PyUnicode_Check
- #define PyString_CheckExact PyUnicode_CheckExact
-#ifndef PyObject_Unicode
- #define PyObject_Unicode PyObject_Str
-#endif
-#endif
-#if PY_MAJOR_VERSION >= 3
- #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
- #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
-#else
- #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
- #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
-#endif
-#if CYTHON_COMPILING_IN_CPYTHON
- #define __Pyx_PySequence_ListKeepNew(obj)\
- (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj))
-#else
- #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj)
-#endif
-#ifndef PySet_CheckExact
- #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type)
-#endif
-#if PY_VERSION_HEX >= 0x030900A4
- #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
- #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size)
-#else
- #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt)
- #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
-#endif
-#if CYTHON_ASSUME_SAFE_MACROS
- #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq)
-#else
- #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq)
-#endif
-#if PY_MAJOR_VERSION >= 3
- #define PyIntObject PyLongObject
- #define PyInt_Type PyLong_Type
- #define PyInt_Check(op) PyLong_Check(op)
- #define PyInt_CheckExact(op) PyLong_CheckExact(op)
- #define __Pyx_Py3Int_Check(op) PyLong_Check(op)
- #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op)
- #define PyInt_FromString PyLong_FromString
- #define PyInt_FromUnicode PyLong_FromUnicode
- #define PyInt_FromLong PyLong_FromLong
- #define PyInt_FromSize_t PyLong_FromSize_t
- #define PyInt_FromSsize_t PyLong_FromSsize_t
- #define PyInt_AsLong PyLong_AsLong
- #define PyInt_AS_LONG PyLong_AS_LONG
- #define PyInt_AsSsize_t PyLong_AsSsize_t
- #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask
- #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
- #define PyNumber_Int PyNumber_Long
-#else
- #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op))
- #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op))
-#endif
-#if PY_MAJOR_VERSION >= 3
- #define PyBoolObject PyLongObject
-#endif
-#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY
- #ifndef PyUnicode_InternFromString
- #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
- #endif
-#endif
-#if PY_VERSION_HEX < 0x030200A4
- typedef long Py_hash_t;
- #define __Pyx_PyInt_FromHash_t PyInt_FromLong
- #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t
-#else
- #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
- #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t
-#endif
-#if CYTHON_USE_ASYNC_SLOTS
- #if PY_VERSION_HEX >= 0x030500B1
- #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
- #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)
- #else
- #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))
- #endif
-#else
- #define __Pyx_PyType_AsAsync(obj) NULL
-#endif
-#ifndef __Pyx_PyAsyncMethodsStruct
- typedef struct {
- unaryfunc am_await;
- unaryfunc am_aiter;
- unaryfunc am_anext;
- } __Pyx_PyAsyncMethodsStruct;
-#endif
-
-#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS)
- #if !defined(_USE_MATH_DEFINES)
- #define _USE_MATH_DEFINES
- #endif
-#endif
-#include
-#ifdef NAN
-#define __PYX_NAN() ((float) NAN)
-#else
-static CYTHON_INLINE float __PYX_NAN() {
- float value;
- memset(&value, 0xFF, sizeof(value));
- return value;
-}
-#endif
-#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL)
-#define __Pyx_truncl trunc
-#else
-#define __Pyx_truncl truncl
-#endif
-
-#define __PYX_MARK_ERR_POS(f_index, lineno) \
- { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
-#define __PYX_ERR(f_index, lineno, Ln_error) \
- { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
-
-#ifdef CYTHON_EXTERN_C
- #undef __PYX_EXTERN_C
- #define __PYX_EXTERN_C CYTHON_EXTERN_C
-#elif defined(__PYX_EXTERN_C)
- #ifdef _MSC_VER
- #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
- #else
- #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
- #endif
-#else
- #ifdef __cplusplus
- #define __PYX_EXTERN_C extern "C"
- #else
- #define __PYX_EXTERN_C extern
- #endif
-#endif
-
-#define __PYX_HAVE__monotonic_align__core
-#define __PYX_HAVE_API__monotonic_align__core
-/* Early includes */
-#include "pythread.h"
-#include
-#include
-#ifdef _OPENMP
-#include
-#endif /* _OPENMP */
-
-#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS)
-#define CYTHON_WITHOUT_ASSERTIONS
-#endif
-
-typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;
- const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;
-
-#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
-#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0
-#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8)
-#define __PYX_DEFAULT_STRING_ENCODING ""
-#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
-#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
-#define __Pyx_uchar_cast(c) ((unsigned char)c)
-#define __Pyx_long_cast(x) ((long)x)
-#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\
- (sizeof(type) < sizeof(Py_ssize_t)) ||\
- (sizeof(type) > sizeof(Py_ssize_t) &&\
- likely(v < (type)PY_SSIZE_T_MAX ||\
- v == (type)PY_SSIZE_T_MAX) &&\
- (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\
- v == (type)PY_SSIZE_T_MIN))) ||\
- (sizeof(type) == sizeof(Py_ssize_t) &&\
- (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\
- v == (type)PY_SSIZE_T_MAX))) )
-static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
- return (size_t) i < (size_t) limit;
-}
-#if defined (__cplusplus) && __cplusplus >= 201103L
- #include
- #define __Pyx_sst_abs(value) std::abs(value)
-#elif SIZEOF_INT >= SIZEOF_SIZE_T
- #define __Pyx_sst_abs(value) abs(value)
-#elif SIZEOF_LONG >= SIZEOF_SIZE_T
- #define __Pyx_sst_abs(value) labs(value)
-#elif defined (_MSC_VER)
- #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value))
-#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
- #define __Pyx_sst_abs(value) llabs(value)
-#elif defined (__GNUC__)
- #define __Pyx_sst_abs(value) __builtin_llabs(value)
-#else
- #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
-#endif
-static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
-static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
-#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
-#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
-#define __Pyx_PyBytes_FromString PyBytes_FromString
-#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
-static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
-#if PY_MAJOR_VERSION < 3
- #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString
- #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
-#else
- #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString
- #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize
-#endif
-#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s)
-#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s)
-#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s)
-#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s)
-#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
-#if CYTHON_COMPILING_IN_LIMITED_API
-static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const wchar_t *u)
-{
- const wchar_t *u_end = u;
- while (*u_end++) ;
- return (size_t)(u_end - u - 1);
-}
-#else
-static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u)
-{
- const Py_UNICODE *u_end = u;
- while (*u_end++) ;
- return (size_t)(u_end - u - 1);
-}
-#endif
-#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o)
-#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
-#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
-#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode
-#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
-#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
-static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b);
-static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
-static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*);
-static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
-#define __Pyx_PySequence_Tuple(obj)\
- (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj))
-static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
-static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
-static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
-#if CYTHON_ASSUME_SAFE_MACROS
-#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
-#else
-#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
-#endif
-#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
-#if PY_MAJOR_VERSION >= 3
-#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
-#else
-#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
-#endif
-#if CYTHON_USE_PYLONG_INTERNALS
- #if PY_VERSION_HEX >= 0x030C00A7
- #ifndef _PyLong_SIGN_MASK
- #define _PyLong_SIGN_MASK 3
- #endif
- #ifndef _PyLong_NON_SIZE_BITS
- #define _PyLong_NON_SIZE_BITS 3
- #endif
- #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)
- #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0)
- #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x))
- #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1)
- #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0)
- #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0])
- #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS))
- #define __Pyx_PyLong_SignedDigitCount(x)\
- ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x))
- #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue)
- #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x)
- #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x)
- #else
- #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS))
- #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0])
- #endif
- typedef Py_ssize_t __Pyx_compact_pylong;
- typedef size_t __Pyx_compact_upylong;
- #else // Py < 3.12
- #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0)
- #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0)
- #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0)
- #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0)
- #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0])
- #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x))
- #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x)
- #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1)
- #define __Pyx_PyLong_CompactValue(x)\
- ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0]))
- typedef sdigit __Pyx_compact_pylong;
- typedef digit __Pyx_compact_upylong;
- #endif
- #if PY_VERSION_HEX >= 0x030C00A5
- #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit)
- #else
- #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit)
- #endif
-#endif
-#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
-static int __Pyx_sys_getdefaultencoding_not_ascii;
-static int __Pyx_init_sys_getdefaultencoding_params(void) {
- PyObject* sys;
- PyObject* default_encoding = NULL;
- PyObject* ascii_chars_u = NULL;
- PyObject* ascii_chars_b = NULL;
- const char* default_encoding_c;
- sys = PyImport_ImportModule("sys");
- if (!sys) goto bad;
- default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL);
- Py_DECREF(sys);
- if (!default_encoding) goto bad;
- default_encoding_c = PyBytes_AsString(default_encoding);
- if (!default_encoding_c) goto bad;
- if (strcmp(default_encoding_c, "ascii") == 0) {
- __Pyx_sys_getdefaultencoding_not_ascii = 0;
- } else {
- char ascii_chars[128];
- int c;
- for (c = 0; c < 128; c++) {
- ascii_chars[c] = (char) c;
- }
- __Pyx_sys_getdefaultencoding_not_ascii = 1;
- ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
- if (!ascii_chars_u) goto bad;
- ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);
- if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {
- PyErr_Format(
- PyExc_ValueError,
- "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",
- default_encoding_c);
- goto bad;
- }
- Py_DECREF(ascii_chars_u);
- Py_DECREF(ascii_chars_b);
- }
- Py_DECREF(default_encoding);
- return 0;
-bad:
- Py_XDECREF(default_encoding);
- Py_XDECREF(ascii_chars_u);
- Py_XDECREF(ascii_chars_b);
- return -1;
-}
-#endif
-#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3
-#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
-#else
-#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
-#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
-static char* __PYX_DEFAULT_STRING_ENCODING;
-static int __Pyx_init_sys_getdefaultencoding_params(void) {
- PyObject* sys;
- PyObject* default_encoding = NULL;
- char* default_encoding_c;
- sys = PyImport_ImportModule("sys");
- if (!sys) goto bad;
- default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);
- Py_DECREF(sys);
- if (!default_encoding) goto bad;
- default_encoding_c = PyBytes_AsString(default_encoding);
- if (!default_encoding_c) goto bad;
- __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1);
- if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;
- strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);
- Py_DECREF(default_encoding);
- return 0;
-bad:
- Py_XDECREF(default_encoding);
- return -1;
-}
-#endif
-#endif
-
-
-/* Test for GCC > 2.95 */
-#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
- #define likely(x) __builtin_expect(!!(x), 1)
- #define unlikely(x) __builtin_expect(!!(x), 0)
-#else /* !__GNUC__ or GCC < 2.95 */
- #define likely(x) (x)
- #define unlikely(x) (x)
-#endif /* __GNUC__ */
-static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
-
-#if !CYTHON_USE_MODULE_STATE
-static PyObject *__pyx_m = NULL;
-#endif
-static int __pyx_lineno;
-static int __pyx_clineno = 0;
-static const char * __pyx_cfilenm = __FILE__;
-static const char *__pyx_filename;
-
-/* #### Code section: filename_table ### */
-
-static const char *__pyx_f[] = {
- "core.pyx",
- "",
-};
-/* #### Code section: utility_code_proto_before_types ### */
-/* ForceInitThreads.proto */
-#ifndef __PYX_FORCE_INIT_THREADS
- #define __PYX_FORCE_INIT_THREADS 0
-#endif
-
-/* NoFastGil.proto */
-#define __Pyx_PyGILState_Ensure PyGILState_Ensure
-#define __Pyx_PyGILState_Release PyGILState_Release
-#define __Pyx_FastGIL_Remember()
-#define __Pyx_FastGIL_Forget()
-#define __Pyx_FastGilFuncInit()
-
-/* BufferFormatStructs.proto */
-struct __Pyx_StructField_;
-#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0)
-typedef struct {
- const char* name;
- struct __Pyx_StructField_* fields;
- size_t size;
- size_t arraysize[8];
- int ndim;
- char typegroup;
- char is_unsigned;
- int flags;
-} __Pyx_TypeInfo;
-typedef struct __Pyx_StructField_ {
- __Pyx_TypeInfo* type;
- const char* name;
- size_t offset;
-} __Pyx_StructField;
-typedef struct {
- __Pyx_StructField* field;
- size_t parent_offset;
-} __Pyx_BufFmt_StackElem;
-typedef struct {
- __Pyx_StructField root;
- __Pyx_BufFmt_StackElem* head;
- size_t fmt_offset;
- size_t new_count, enc_count;
- size_t struct_alignment;
- int is_complex;
- char enc_type;
- char new_packmode;
- char enc_packmode;
- char is_valid_array;
-} __Pyx_BufFmt_Context;
-
-/* Atomics.proto */
-#include
-#ifndef CYTHON_ATOMICS
- #define CYTHON_ATOMICS 1
-#endif
-#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS
-#define __pyx_atomic_int_type int
-#define __pyx_nonatomic_int_type int
-#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\
- (__STDC_VERSION__ >= 201112L) &&\
- !defined(__STDC_NO_ATOMICS__))
- #include
-#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\
- (__cplusplus >= 201103L) ||\
- (defined(_MSC_VER) && _MSC_VER >= 1700)))
- #include
-#endif
-#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\
- (__STDC_VERSION__ >= 201112L) &&\
- !defined(__STDC_NO_ATOMICS__) &&\
- ATOMIC_INT_LOCK_FREE == 2)
- #undef __pyx_atomic_int_type
- #define __pyx_atomic_int_type atomic_int
- #define __pyx_atomic_incr_aligned(value) atomic_fetch_add_explicit(value, 1, memory_order_relaxed)
- #define __pyx_atomic_decr_aligned(value) atomic_fetch_sub_explicit(value, 1, memory_order_acq_rel)
- #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER)
- #pragma message ("Using standard C atomics")
- #elif defined(__PYX_DEBUG_ATOMICS)
- #warning "Using standard C atomics"
- #endif
-#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\
- (__cplusplus >= 201103L) ||\
-\
- (defined(_MSC_VER) && _MSC_VER >= 1700)) &&\
- ATOMIC_INT_LOCK_FREE == 2)
- #undef __pyx_atomic_int_type
- #define __pyx_atomic_int_type std::atomic_int
- #define __pyx_atomic_incr_aligned(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_relaxed)
- #define __pyx_atomic_decr_aligned(value) std::atomic_fetch_sub_explicit(value, 1, std::memory_order_acq_rel)
- #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER)
- #pragma message ("Using standard C++ atomics")
- #elif defined(__PYX_DEBUG_ATOMICS)
- #warning "Using standard C++ atomics"
- #endif
-#elif CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\
- (__GNUC_MINOR__ > 1 ||\
- (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2))))
- #define __pyx_atomic_incr_aligned(value) __sync_fetch_and_add(value, 1)
- #define __pyx_atomic_decr_aligned(value) __sync_fetch_and_sub(value, 1)
- #ifdef __PYX_DEBUG_ATOMICS
- #warning "Using GNU atomics"
- #endif
-#elif CYTHON_ATOMICS && defined(_MSC_VER)
- #include
- #undef __pyx_atomic_int_type
- #define __pyx_atomic_int_type long
- #define __pyx_nonatomic_int_type long
- #pragma intrinsic (_InterlockedExchangeAdd)
- #define __pyx_atomic_incr_aligned(value) _InterlockedExchangeAdd(value, 1)
- #define __pyx_atomic_decr_aligned(value) _InterlockedExchangeAdd(value, -1)
- #ifdef __PYX_DEBUG_ATOMICS
- #pragma message ("Using MSVC atomics")
- #endif
-#else
- #undef CYTHON_ATOMICS
- #define CYTHON_ATOMICS 0
- #ifdef __PYX_DEBUG_ATOMICS
- #warning "Not using atomics"
- #endif
-#endif
-#if CYTHON_ATOMICS
- #define __pyx_add_acquisition_count(memview)\
- __pyx_atomic_incr_aligned(__pyx_get_slice_count_pointer(memview))
- #define __pyx_sub_acquisition_count(memview)\
- __pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview))
-#else
- #define __pyx_add_acquisition_count(memview)\
- __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock)
- #define __pyx_sub_acquisition_count(memview)\
- __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock)
-#endif
-
-/* MemviewSliceStruct.proto */
-struct __pyx_memoryview_obj;
-typedef struct {
- struct __pyx_memoryview_obj *memview;
- char *data;
- Py_ssize_t shape[8];
- Py_ssize_t strides[8];
- Py_ssize_t suboffsets[8];
-} __Pyx_memviewslice;
-#define __Pyx_MemoryView_Len(m) (m.shape[0])
-
-/* #### Code section: numeric_typedefs ### */
-/* #### Code section: complex_type_declarations ### */
-/* #### Code section: type_declarations ### */
-
-/*--- Type declarations ---*/
-struct __pyx_array_obj;
-struct __pyx_MemviewEnum_obj;
-struct __pyx_memoryview_obj;
-struct __pyx_memoryviewslice_obj;
-struct __pyx_opt_args_15monotonic_align_4core_maximum_path_each;
-
-/* "monotonic_align/core.pyx":7
- * @cython.boundscheck(False)
- * @cython.wraparound(False)
- * cdef void maximum_path_each(int[:,::1] path, float[:,::1] value, int t_y, int t_x, float max_neg_val=-1e9) nogil: # <<<<<<<<<<<<<<
- * cdef int x
- * cdef int y
- */
-struct __pyx_opt_args_15monotonic_align_4core_maximum_path_each {
- int __pyx_n;
- float max_neg_val;
-};
-
-/* "View.MemoryView":114
- * @cython.collection_type("sequence")
- * @cname("__pyx_array")
- * cdef class array: # <<<<<<<<<<<<<<
- *
- * cdef:
- */
-struct __pyx_array_obj {
- PyObject_HEAD
- struct __pyx_vtabstruct_array *__pyx_vtab;
- char *data;
- Py_ssize_t len;
- char *format;
- int ndim;
- Py_ssize_t *_shape;
- Py_ssize_t *_strides;
- Py_ssize_t itemsize;
- PyObject *mode;
- PyObject *_format;
- void (*callback_free_data)(void *);
- int free_data;
- int dtype_is_object;
-};
-
-
-/* "View.MemoryView":302
- *
- * @cname('__pyx_MemviewEnum')
- * cdef class Enum(object): # <<<<<<<<<<<<<<
- * cdef object name
- * def __init__(self, name):
- */
-struct __pyx_MemviewEnum_obj {
- PyObject_HEAD
- PyObject *name;
-};
-
-
-/* "View.MemoryView":337
- *
- * @cname('__pyx_memoryview')
- * cdef class memoryview: # <<<<<<<<<<<<<<
- *
- * cdef object obj
- */
-struct __pyx_memoryview_obj {
- PyObject_HEAD
- struct __pyx_vtabstruct_memoryview *__pyx_vtab;
- PyObject *obj;
- PyObject *_size;
- PyObject *_array_interface;
- PyThread_type_lock lock;
- __pyx_atomic_int_type acquisition_count;
- Py_buffer view;
- int flags;
- int dtype_is_object;
- __Pyx_TypeInfo *typeinfo;
-};
-
-
-/* "View.MemoryView":952
- * @cython.collection_type("sequence")
- * @cname('__pyx_memoryviewslice')
- * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<<
- * "Internal class for passing memoryview slices to Python"
- *
- */
-struct __pyx_memoryviewslice_obj {
- struct __pyx_memoryview_obj __pyx_base;
- __Pyx_memviewslice from_slice;
- PyObject *from_object;
- PyObject *(*to_object_func)(char *);
- int (*to_dtype_func)(char *, PyObject *);
-};
-
-
-
-/* "View.MemoryView":114
- * @cython.collection_type("sequence")
- * @cname("__pyx_array")
- * cdef class array: # <<<<<<<<<<<<<<
- *
- * cdef:
- */
-
-struct __pyx_vtabstruct_array {
- PyObject *(*get_memview)(struct __pyx_array_obj *);
-};
-static struct __pyx_vtabstruct_array *__pyx_vtabptr_array;
-
-
-/* "View.MemoryView":337
- *
- * @cname('__pyx_memoryview')
- * cdef class memoryview: # <<<<<<<<<<<<<<
- *
- * cdef object obj
- */
-
-struct __pyx_vtabstruct_memoryview {
- char *(*get_item_pointer)(struct __pyx_memoryview_obj *, PyObject *);
- PyObject *(*is_slice)(struct __pyx_memoryview_obj *, PyObject *);
- PyObject *(*setitem_slice_assignment)(struct __pyx_memoryview_obj *, PyObject *, PyObject *);
- PyObject *(*setitem_slice_assign_scalar)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *);
- PyObject *(*setitem_indexed)(struct __pyx_memoryview_obj *, PyObject *, PyObject *);
- PyObject *(*convert_item_to_object)(struct __pyx_memoryview_obj *, char *);
- PyObject *(*assign_item_from_object)(struct __pyx_memoryview_obj *, char *, PyObject *);
- PyObject *(*_get_base)(struct __pyx_memoryview_obj *);
-};
-static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview;
-
-
-/* "View.MemoryView":952
- * @cython.collection_type("sequence")
- * @cname('__pyx_memoryviewslice')
- * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<<
- * "Internal class for passing memoryview slices to Python"
- *
- */
-
-struct __pyx_vtabstruct__memoryviewslice {
- struct __pyx_vtabstruct_memoryview __pyx_base;
-};
-static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice;
-/* #### Code section: utility_code_proto ### */
-
-/* --- Runtime support code (head) --- */
-/* Refnanny.proto */
-#ifndef CYTHON_REFNANNY
- #define CYTHON_REFNANNY 0
-#endif
-#if CYTHON_REFNANNY
- typedef struct {
- void (*INCREF)(void*, PyObject*, Py_ssize_t);
- void (*DECREF)(void*, PyObject*, Py_ssize_t);
- void (*GOTREF)(void*, PyObject*, Py_ssize_t);
- void (*GIVEREF)(void*, PyObject*, Py_ssize_t);
- void* (*SetupContext)(const char*, Py_ssize_t, const char*);
- void (*FinishContext)(void**);
- } __Pyx_RefNannyAPIStruct;
- static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
- static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
- #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
-#ifdef WITH_THREAD
- #define __Pyx_RefNannySetupContext(name, acquire_gil)\
- if (acquire_gil) {\
- PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
- __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
- PyGILState_Release(__pyx_gilstate_save);\
- } else {\
- __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
- }
- #define __Pyx_RefNannyFinishContextNogil() {\
- PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
- __Pyx_RefNannyFinishContext();\
- PyGILState_Release(__pyx_gilstate_save);\
- }
-#else
- #define __Pyx_RefNannySetupContext(name, acquire_gil)\
- __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__))
- #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext()
-#endif
- #define __Pyx_RefNannyFinishContextNogil() {\
- PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
- __Pyx_RefNannyFinishContext();\
- PyGILState_Release(__pyx_gilstate_save);\
- }
- #define __Pyx_RefNannyFinishContext()\
- __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
- #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
- #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
- #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
- #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
- #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0)
- #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0)
- #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0)
- #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0)
-#else
- #define __Pyx_RefNannyDeclarations
- #define __Pyx_RefNannySetupContext(name, acquire_gil)
- #define __Pyx_RefNannyFinishContextNogil()
- #define __Pyx_RefNannyFinishContext()
- #define __Pyx_INCREF(r) Py_INCREF(r)
- #define __Pyx_DECREF(r) Py_DECREF(r)
- #define __Pyx_GOTREF(r)
- #define __Pyx_GIVEREF(r)
- #define __Pyx_XINCREF(r) Py_XINCREF(r)
- #define __Pyx_XDECREF(r) Py_XDECREF(r)
- #define __Pyx_XGOTREF(r)
- #define __Pyx_XGIVEREF(r)
-#endif
-#define __Pyx_Py_XDECREF_SET(r, v) do {\
- PyObject *tmp = (PyObject *) r;\
- r = v; Py_XDECREF(tmp);\
- } while (0)
-#define __Pyx_XDECREF_SET(r, v) do {\
- PyObject *tmp = (PyObject *) r;\
- r = v; __Pyx_XDECREF(tmp);\
- } while (0)
-#define __Pyx_DECREF_SET(r, v) do {\
- PyObject *tmp = (PyObject *) r;\
- r = v; __Pyx_DECREF(tmp);\
- } while (0)
-#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
-#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
-
-/* PyErrExceptionMatches.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
-#else
-#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err)
-#endif
-
-/* PyThreadStateGet.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate;
-#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current;
-#if PY_VERSION_HEX >= 0x030C00A6
-#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL)
-#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL)
-#else
-#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL)
-#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type)
-#endif
-#else
-#define __Pyx_PyThreadState_declare
-#define __Pyx_PyThreadState_assign
-#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL)
-#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred()
-#endif
-
-/* PyErrFetchRestore.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
-#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
-#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
-#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
-#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6
-#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
-#else
-#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
-#endif
-#else
-#define __Pyx_PyErr_Clear() PyErr_Clear()
-#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
-#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb)
-#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb)
-#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb)
-#endif
-
-/* PyObjectGetAttrStr.proto */
-#if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
-#else
-#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
-#endif
-
-/* PyObjectGetAttrStrNoError.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
-
-/* GetBuiltinName.proto */
-static PyObject *__Pyx_GetBuiltinName(PyObject *name);
-
-/* TupleAndListFromArray.proto */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n);
-static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n);
-#endif
-
-/* IncludeStringH.proto */
-#include
-
-/* BytesEquals.proto */
-static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
-
-/* UnicodeEquals.proto */
-static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
-
-/* fastcall.proto */
-#define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i)
-#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds)
-#define __Pyx_KwValues_VARARGS(args, nargs) NULL
-#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s)
-#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw)
-#if CYTHON_METH_FASTCALL
- #define __Pyx_Arg_FASTCALL(args, i) args[i]
- #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds)
- #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs))
- static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s);
- #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw)
-#else
- #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS
- #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS
- #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS
- #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS
- #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS
-#endif
-#if CYTHON_COMPILING_IN_CPYTHON
-#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start)
-#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start)
-#else
-#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop)
-#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop)
-#endif
-
-/* RaiseArgTupleInvalid.proto */
-static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
- Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
-
-/* RaiseDoubleKeywords.proto */
-static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
-
-/* ParseKeywords.proto */
-static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues,
- PyObject **argnames[],
- PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,
- const char* function_name);
-
-/* ArgTypeTest.proto */
-#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
- ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\
- __Pyx__ArgTypeTest(obj, type, name, exact))
-static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);
-
-/* RaiseException.proto */
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
-
-/* PyFunctionFastCall.proto */
-#if CYTHON_FAST_PYCALL
-#if !CYTHON_VECTORCALL
-#define __Pyx_PyFunction_FastCall(func, args, nargs)\
- __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
-static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs);
-#endif
-#define __Pyx_BUILD_ASSERT_EXPR(cond)\
- (sizeof(char [1 - 2*!(cond)]) - 1)
-#ifndef Py_MEMBER_SIZE
-#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
-#endif
-#if !CYTHON_VECTORCALL
-#if PY_VERSION_HEX >= 0x03080000
- #include "frameobject.h"
-#if PY_VERSION_HEX >= 0x030b00a6
- #ifndef Py_BUILD_CORE
- #define Py_BUILD_CORE 1
- #endif
- #include "internal/pycore_frame.h"
-#endif
- #define __Pxy_PyFrame_Initialize_Offsets()
- #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus)
-#else
- static size_t __pyx_pyframe_localsplus_offset = 0;
- #include "frameobject.h"
- #define __Pxy_PyFrame_Initialize_Offsets()\
- ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\
- (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))
- #define __Pyx_PyFrame_GetLocalsplus(frame)\
- (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
-#endif
-#endif
-#endif
-
-/* PyObjectCall.proto */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
-#else
-#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
-#endif
-
-/* PyObjectCallMethO.proto */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
-#endif
-
-/* PyObjectFastCall.proto */
-#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL)
-static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs);
-
-/* RaiseUnexpectedTypeError.proto */
-static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj);
-
-/* GCCDiagnostics.proto */
-#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
-#define __Pyx_HAS_GCC_DIAGNOSTIC
-#endif
-
-/* BuildPyUnicode.proto */
-static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength,
- int prepend_sign, char padding_char);
-
-/* CIntToPyUnicode.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char);
-
-/* CIntToPyUnicode.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char);
-
-/* JoinPyUnicode.proto */
-static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength,
- Py_UCS4 max_char);
-
-/* StrEquals.proto */
-#if PY_MAJOR_VERSION >= 3
-#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals
-#else
-#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals
-#endif
-
-/* PyObjectFormatSimple.proto */
-#if CYTHON_COMPILING_IN_PYPY
- #define __Pyx_PyObject_FormatSimple(s, f) (\
- likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\
- PyObject_Format(s, f))
-#elif PY_MAJOR_VERSION < 3
- #define __Pyx_PyObject_FormatSimple(s, f) (\
- likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\
- likely(PyString_CheckExact(s)) ? PyUnicode_FromEncodedObject(s, NULL, "strict") :\
- PyObject_Format(s, f))
-#elif CYTHON_USE_TYPE_SLOTS
- #define __Pyx_PyObject_FormatSimple(s, f) (\
- likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\
- likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_repr(s) :\
- likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_repr(s) :\
- PyObject_Format(s, f))
-#else
- #define __Pyx_PyObject_FormatSimple(s, f) (\
- likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\
- PyObject_Format(s, f))
-#endif
-
-CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
-static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *); /*proto*/
-/* GetAttr.proto */
-static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *);
-
-/* GetItemInt.proto */
-#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
- (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
- __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\
- (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\
- __Pyx_GetItemInt_Generic(o, to_py_func(i))))
-#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
- (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
- __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
- (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL))
-static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
- int wraparound, int boundscheck);
-#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
- (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
- __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
- (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL))
-static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
- int wraparound, int boundscheck);
-static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j);
-static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
- int is_list, int wraparound, int boundscheck);
-
-/* PyObjectCallOneArg.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
-
-/* ObjectGetItem.proto */
-#if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key);
-#else
-#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key)
-#endif
-
-/* KeywordStringCheck.proto */
-static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed);
-
-/* DivInt[Py_ssize_t].proto */
-static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t, Py_ssize_t);
-
-/* UnaryNegOverflows.proto */
-#define __Pyx_UNARY_NEG_WOULD_OVERFLOW(x)\
- (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x)))
-
-/* GetAttr3.proto */
-static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *);
-
-/* PyDictVersioning.proto */
-#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
-#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1)
-#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag)
-#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\
- (version_var) = __PYX_GET_DICT_VERSION(dict);\
- (cache_var) = (value);
-#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\
- static PY_UINT64_T __pyx_dict_version = 0;\
- static PyObject *__pyx_dict_cached_value = NULL;\
- if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\
- (VAR) = __pyx_dict_cached_value;\
- } else {\
- (VAR) = __pyx_dict_cached_value = (LOOKUP);\
- __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\
- }\
-}
-static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj);
-static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj);
-static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version);
-#else
-#define __PYX_GET_DICT_VERSION(dict) (0)
-#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)
-#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP);
-#endif
-
-/* GetModuleGlobalName.proto */
-#if CYTHON_USE_DICT_VERSIONS
-#define __Pyx_GetModuleGlobalName(var, name) do {\
- static PY_UINT64_T __pyx_dict_version = 0;\
- static PyObject *__pyx_dict_cached_value = NULL;\
- (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\
- (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\
- __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
-} while(0)
-#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\
- PY_UINT64_T __pyx_dict_version;\
- PyObject *__pyx_dict_cached_value;\
- (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
-} while(0)
-static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value);
-#else
-#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name)
-#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name)
-static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name);
-#endif
-
-/* AssertionsEnabled.proto */
-#define __Pyx_init_assertions_enabled()
-#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
- #define __pyx_assertions_enabled() (1)
-#elif PY_VERSION_HEX < 0x03080000 || CYTHON_COMPILING_IN_PYPY || defined(Py_LIMITED_API)
- #define __pyx_assertions_enabled() (!Py_OptimizeFlag)
-#elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030900A6
- static int __pyx_assertions_enabled_flag;
- #define __pyx_assertions_enabled() (__pyx_assertions_enabled_flag)
- #undef __Pyx_init_assertions_enabled
- static void __Pyx_init_assertions_enabled(void) {
- __pyx_assertions_enabled_flag = ! _PyInterpreterState_GetConfig(__Pyx_PyThreadState_Current->interp)->optimization_level;
- }
-#else
- #define __pyx_assertions_enabled() (!Py_OptimizeFlag)
-#endif
-
-/* RaiseTooManyValuesToUnpack.proto */
-static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);
-
-/* RaiseNeedMoreValuesToUnpack.proto */
-static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);
-
-/* RaiseNoneIterError.proto */
-static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);
-
-/* ExtTypeTest.proto */
-static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);
-
-/* GetTopmostException.proto */
-#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
-static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate);
-#endif
-
-/* SaveResetException.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb)
-static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
-#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb)
-static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
-#else
-#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb)
-#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb)
-#endif
-
-/* GetException.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb)
-static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
-#else
-static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb);
-#endif
-
-/* SwapException.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb)
-static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
-#else
-static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb);
-#endif
-
-/* Import.proto */
-static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);
-
-/* ImportDottedModule.proto */
-static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple);
-#if PY_MAJOR_VERSION >= 3
-static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple);
-#endif
-
-/* ssize_strlen.proto */
-static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s);
-
-/* FastTypeChecks.proto */
-#if CYTHON_COMPILING_IN_CPYTHON
-#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
-#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2)
-static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
-static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b);
-static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
-static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
-#else
-#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
-#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2))
-#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
-#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
-#endif
-#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2)
-#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
-
-CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
-/* ListCompAppend.proto */
-#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
-static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
- PyListObject* L = (PyListObject*) list;
- Py_ssize_t len = Py_SIZE(list);
- if (likely(L->allocated > len)) {
- Py_INCREF(x);
- PyList_SET_ITEM(list, len, x);
- __Pyx_SET_SIZE(list, len + 1);
- return 0;
- }
- return PyList_Append(list, x);
-}
-#else
-#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x)
-#endif
-
-/* PySequenceMultiply.proto */
-#define __Pyx_PySequence_Multiply_Left(mul, seq) __Pyx_PySequence_Multiply(seq, mul)
-static CYTHON_INLINE PyObject* __Pyx_PySequence_Multiply(PyObject *seq, Py_ssize_t mul);
-
-/* SetItemInt.proto */
-#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
- (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
- __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\
- (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\
- __Pyx_SetItemInt_Generic(o, to_py_func(i), v)))
-static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v);
-static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v,
- int is_list, int wraparound, int boundscheck);
-
-/* RaiseUnboundLocalError.proto */
-static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname);
-
-/* DivInt[long].proto */
-static CYTHON_INLINE long __Pyx_div_long(long, long);
-
-/* PySequenceContains.proto */
-static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) {
- int result = PySequence_Contains(seq, item);
- return unlikely(result < 0) ? result : (result == (eq == Py_EQ));
-}
-
-/* ImportFrom.proto */
-static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name);
-
-/* HasAttr.proto */
-static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *);
-
-/* ErrOccurredWithGIL.proto */
-static CYTHON_INLINE int __Pyx_ErrOccurredWithGIL(void);
-
-/* PyObject_GenericGetAttrNoDict.proto */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name);
-#else
-#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr
-#endif
-
-/* PyObject_GenericGetAttr.proto */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name);
-#else
-#define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr
-#endif
-
-/* IncludeStructmemberH.proto */
-#include
-
-/* FixUpExtensionType.proto */
-#if CYTHON_USE_TYPE_SPECS
-static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type);
-#endif
-
-/* PyObjectCallNoArg.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
-
-/* PyObjectGetMethod.proto */
-static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
-
-/* PyObjectCallMethod0.proto */
-static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name);
-
-/* ValidateBasesTuple.proto */
-#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
-static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases);
-#endif
-
-/* PyType_Ready.proto */
-CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t);
-
-/* SetVTable.proto */
-static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable);
-
-/* GetVTable.proto */
-static void* __Pyx_GetVtable(PyTypeObject *type);
-
-/* MergeVTables.proto */
-#if !CYTHON_COMPILING_IN_LIMITED_API
-static int __Pyx_MergeVtables(PyTypeObject *type);
-#endif
-
-/* SetupReduce.proto */
-#if !CYTHON_COMPILING_IN_LIMITED_API
-static int __Pyx_setup_reduce(PyObject* type_obj);
-#endif
-
-/* FetchSharedCythonModule.proto */
-static PyObject *__Pyx_FetchSharedCythonABIModule(void);
-
-/* FetchCommonType.proto */
-#if !CYTHON_USE_TYPE_SPECS
-static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
-#else
-static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases);
-#endif
-
-/* PyMethodNew.proto */
-#if PY_MAJOR_VERSION >= 3
-static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
- CYTHON_UNUSED_VAR(typ);
- if (!self)
- return __Pyx_NewRef(func);
- return PyMethod_New(func, self);
-}
-#else
- #define __Pyx_PyMethod_New PyMethod_New
-#endif
-
-/* PyVectorcallFastCallDict.proto */
-#if CYTHON_METH_FASTCALL
-static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw);
-#endif
-
-/* CythonFunctionShared.proto */
-#define __Pyx_CyFunction_USED
-#define __Pyx_CYFUNCTION_STATICMETHOD 0x01
-#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02
-#define __Pyx_CYFUNCTION_CCLASS 0x04
-#define __Pyx_CYFUNCTION_COROUTINE 0x08
-#define __Pyx_CyFunction_GetClosure(f)\
- (((__pyx_CyFunctionObject *) (f))->func_closure)
-#if PY_VERSION_HEX < 0x030900B1
- #define __Pyx_CyFunction_GetClassObj(f)\
- (((__pyx_CyFunctionObject *) (f))->func_classobj)
-#else
- #define __Pyx_CyFunction_GetClassObj(f)\
- ((PyObject*) ((PyCMethodObject *) (f))->mm_class)
-#endif
-#define __Pyx_CyFunction_SetClassObj(f, classobj)\
- __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj))
-#define __Pyx_CyFunction_Defaults(type, f)\
- ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
-#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
- ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
-typedef struct {
-#if PY_VERSION_HEX < 0x030900B1
- PyCFunctionObject func;
-#else
- PyCMethodObject func;
-#endif
-#if CYTHON_BACKPORT_VECTORCALL
- __pyx_vectorcallfunc func_vectorcall;
-#endif
-#if PY_VERSION_HEX < 0x030500A0
- PyObject *func_weakreflist;
-#endif
- PyObject *func_dict;
- PyObject *func_name;
- PyObject *func_qualname;
- PyObject *func_doc;
- PyObject *func_globals;
- PyObject *func_code;
- PyObject *func_closure;
-#if PY_VERSION_HEX < 0x030900B1
- PyObject *func_classobj;
-#endif
- void *defaults;
- int defaults_pyobjects;
- size_t defaults_size; // used by FusedFunction for copying defaults
- int flags;
- PyObject *defaults_tuple;
- PyObject *defaults_kwdict;
- PyObject *(*defaults_getter)(PyObject *);
- PyObject *func_annotations;
- PyObject *func_is_coroutine;
-} __pyx_CyFunctionObject;
-#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType)
-#define __Pyx_IsCyOrPyCFunction(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type)
-#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType)
-static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml,
- int flags, PyObject* qualname,
- PyObject *closure,
- PyObject *module, PyObject *globals,
- PyObject* code);
-static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj);
-static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m,
- size_t size,
- int pyobjects);
-static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
- PyObject *tuple);
-static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
- PyObject *dict);
-static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
- PyObject *dict);
-static int __pyx_CyFunction_init(PyObject *module);
-#if CYTHON_METH_FASTCALL
-static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
-static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
-static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
-static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
-#if CYTHON_BACKPORT_VECTORCALL
-#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall)
-#else
-#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall)
-#endif
-#endif
-
-/* CythonFunction.proto */
-static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
- int flags, PyObject* qualname,
- PyObject *closure,
- PyObject *module, PyObject *globals,
- PyObject* code);
-
-/* CLineInTraceback.proto */
-#ifdef CYTHON_CLINE_IN_TRACEBACK
-#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
-#else
-static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
-#endif
-
-/* CodeObjectCache.proto */
-#if !CYTHON_COMPILING_IN_LIMITED_API
-typedef struct {
- PyCodeObject* code_object;
- int code_line;
-} __Pyx_CodeObjectCacheEntry;
-struct __Pyx_CodeObjectCache {
- int count;
- int max_count;
- __Pyx_CodeObjectCacheEntry* entries;
-};
-static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
-static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
-static PyCodeObject *__pyx_find_code_object(int code_line);
-static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
-#endif
-
-/* AddTraceback.proto */
-static void __Pyx_AddTraceback(const char *funcname, int c_line,
- int py_line, const char *filename);
-
-#if PY_MAJOR_VERSION < 3
- static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags);
- static void __Pyx_ReleaseBuffer(Py_buffer *view);
-#else
- #define __Pyx_GetBuffer PyObject_GetBuffer
- #define __Pyx_ReleaseBuffer PyBuffer_Release
-#endif
-
-
-/* BufferStructDeclare.proto */
-typedef struct {
- Py_ssize_t shape, strides, suboffsets;
-} __Pyx_Buf_DimInfo;
-typedef struct {
- size_t refcount;
- Py_buffer pybuffer;
-} __Pyx_Buffer;
-typedef struct {
- __Pyx_Buffer *rcbuffer;
- char *data;
- __Pyx_Buf_DimInfo diminfo[8];
-} __Pyx_LocalBuf_ND;
-
-/* MemviewSliceIsContig.proto */
-static int __pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim);
-
-/* OverlappingSlices.proto */
-static int __pyx_slices_overlap(__Pyx_memviewslice *slice1,
- __Pyx_memviewslice *slice2,
- int ndim, size_t itemsize);
-
-/* IsLittleEndian.proto */
-static CYTHON_INLINE int __Pyx_Is_Little_Endian(void);
-
-/* BufferFormatCheck.proto */
-static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts);
-static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
- __Pyx_BufFmt_StackElem* stack,
- __Pyx_TypeInfo* type);
-
-/* TypeInfoCompare.proto */
-static int __pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b);
-
-/* MemviewSliceValidateAndInit.proto */
-static int __Pyx_ValidateAndInit_memviewslice(
- int *axes_specs,
- int c_or_f_flag,
- int buf_flags,
- int ndim,
- __Pyx_TypeInfo *dtype,
- __Pyx_BufFmt_StackElem stack[],
- __Pyx_memviewslice *memviewslice,
- PyObject *original_obj);
-
-/* ObjectToMemviewSlice.proto */
-static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_int(PyObject *, int writable_flag);
-
-/* ObjectToMemviewSlice.proto */
-static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_float(PyObject *, int writable_flag);
-
-/* ObjectToMemviewSlice.proto */
-static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_int(PyObject *, int writable_flag);
-
-/* MemviewSliceCopyTemplate.proto */
-static __Pyx_memviewslice
-__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs,
- const char *mode, int ndim,
- size_t sizeof_dtype, int contig_flag,
- int dtype_is_object);
-
-/* MemviewSliceInit.proto */
-#define __Pyx_BUF_MAX_NDIMS %(BUF_MAX_NDIMS)d
-#define __Pyx_MEMVIEW_DIRECT 1
-#define __Pyx_MEMVIEW_PTR 2
-#define __Pyx_MEMVIEW_FULL 4
-#define __Pyx_MEMVIEW_CONTIG 8
-#define __Pyx_MEMVIEW_STRIDED 16
-#define __Pyx_MEMVIEW_FOLLOW 32
-#define __Pyx_IS_C_CONTIG 1
-#define __Pyx_IS_F_CONTIG 2
-static int __Pyx_init_memviewslice(
- struct __pyx_memoryview_obj *memview,
- int ndim,
- __Pyx_memviewslice *memviewslice,
- int memview_is_new_reference);
-static CYTHON_INLINE int __pyx_add_acquisition_count_locked(
- __pyx_atomic_int_type *acquisition_count, PyThread_type_lock lock);
-static CYTHON_INLINE int __pyx_sub_acquisition_count_locked(
- __pyx_atomic_int_type *acquisition_count, PyThread_type_lock lock);
-#define __pyx_get_slice_count_pointer(memview) (&memview->acquisition_count)
-#define __PYX_INC_MEMVIEW(slice, have_gil) __Pyx_INC_MEMVIEW(slice, have_gil, __LINE__)
-#define __PYX_XCLEAR_MEMVIEW(slice, have_gil) __Pyx_XCLEAR_MEMVIEW(slice, have_gil, __LINE__)
-static CYTHON_INLINE void __Pyx_INC_MEMVIEW(__Pyx_memviewslice *, int, int);
-static CYTHON_INLINE void __Pyx_XCLEAR_MEMVIEW(__Pyx_memviewslice *, int, int);
-
-/* CIntToPy.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
-
-/* CIntFromPy.proto */
-static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
-
-/* CIntToPy.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
-
-/* CIntFromPy.proto */
-static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
-
-/* CIntFromPy.proto */
-static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *);
-
-/* FormatTypeName.proto */
-#if CYTHON_COMPILING_IN_LIMITED_API
-typedef PyObject *__Pyx_TypeName;
-#define __Pyx_FMT_TYPENAME "%U"
-static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp);
-#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj)
-#else
-typedef const char *__Pyx_TypeName;
-#define __Pyx_FMT_TYPENAME "%.200s"
-#define __Pyx_PyType_GetName(tp) ((tp)->tp_name)
-#define __Pyx_DECREF_TypeName(obj)
-#endif
-
-/* CheckBinaryVersion.proto */
-static int __Pyx_check_binary_version(void);
-
-/* InitStrings.proto */
-static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
-
-/* #### Code section: module_declarations ### */
-static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self); /* proto*/
-static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto*/
-static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj); /* proto*/
-static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src); /* proto*/
-static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value); /* proto*/
-static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto*/
-static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/
-static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/
-static PyObject *__pyx_memoryview__get_base(struct __pyx_memoryview_obj *__pyx_v_self); /* proto*/
-static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/
-static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/
-static PyObject *__pyx_memoryviewslice__get_base(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto*/
-
-/* Module declarations from "cython.view" */
-
-/* Module declarations from "cython.dataclasses" */
-
-/* Module declarations from "cython" */
-
-/* Module declarations from "monotonic_align.core" */
-static PyObject *__pyx_collections_abc_Sequence = 0;
-static PyObject *generic = 0;
-static PyObject *strided = 0;
-static PyObject *indirect = 0;
-static PyObject *contiguous = 0;
-static PyObject *indirect_contiguous = 0;
-static int __pyx_memoryview_thread_locks_used;
-static PyThread_type_lock __pyx_memoryview_thread_locks[8];
-static void __pyx_f_15monotonic_align_4core_maximum_path_each(__Pyx_memviewslice, __Pyx_memviewslice, int, int, struct __pyx_opt_args_15monotonic_align_4core_maximum_path_each *__pyx_optional_args); /*proto*/
-static void __pyx_f_15monotonic_align_4core_maximum_path_c(__Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, int __pyx_skip_dispatch); /*proto*/
-static int __pyx_array_allocate_buffer(struct __pyx_array_obj *); /*proto*/
-static struct __pyx_array_obj *__pyx_array_new(PyObject *, Py_ssize_t, char *, char *, char *); /*proto*/
-static PyObject *__pyx_memoryview_new(PyObject *, int, int, __Pyx_TypeInfo *); /*proto*/
-static CYTHON_INLINE int __pyx_memoryview_check(PyObject *); /*proto*/
-static PyObject *_unellipsify(PyObject *, int); /*proto*/
-static int assert_direct_dimensions(Py_ssize_t *, int); /*proto*/
-static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *, PyObject *); /*proto*/
-static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int, int); /*proto*/
-static char *__pyx_pybuffer_index(Py_buffer *, char *, Py_ssize_t, Py_ssize_t); /*proto*/
-static int __pyx_memslice_transpose(__Pyx_memviewslice *); /*proto*/
-static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice, int, PyObject *(*)(char *), int (*)(char *, PyObject *), int); /*proto*/
-static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/
-static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/
-static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *); /*proto*/
-static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/
-static Py_ssize_t abs_py_ssize_t(Py_ssize_t); /*proto*/
-static char __pyx_get_best_slice_order(__Pyx_memviewslice *, int); /*proto*/
-static void _copy_strided_to_strided(char *, Py_ssize_t *, char *, Py_ssize_t *, Py_ssize_t *, Py_ssize_t *, int, size_t); /*proto*/
-static void copy_strided_to_strided(__Pyx_memviewslice *, __Pyx_memviewslice *, int, size_t); /*proto*/
-static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *, int); /*proto*/
-static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *, Py_ssize_t *, Py_ssize_t, int, char); /*proto*/
-static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *, __Pyx_memviewslice *, char, int); /*proto*/
-static int __pyx_memoryview_err_extents(int, Py_ssize_t, Py_ssize_t); /*proto*/
-static int __pyx_memoryview_err_dim(PyObject *, PyObject *, int); /*proto*/
-static int __pyx_memoryview_err(PyObject *, PyObject *); /*proto*/
-static int __pyx_memoryview_err_no_memory(void); /*proto*/
-static int __pyx_memoryview_copy_contents(__Pyx_memviewslice, __Pyx_memviewslice, int, int, int); /*proto*/
-static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *, int, int); /*proto*/
-static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *, int, int, int); /*proto*/
-static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/
-static void __pyx_memoryview_refcount_objects_in_slice(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/
-static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *, int, size_t, void *, int); /*proto*/
-static void __pyx_memoryview__slice_assign_scalar(char *, Py_ssize_t *, Py_ssize_t *, int, size_t, void *); /*proto*/
-static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *, PyObject *); /*proto*/
-/* #### Code section: typeinfo ### */
-static __Pyx_TypeInfo __Pyx_TypeInfo_int = { "int", NULL, sizeof(int), { 0 }, 0, __PYX_IS_UNSIGNED(int) ? 'U' : 'I', __PYX_IS_UNSIGNED(int), 0 };
-static __Pyx_TypeInfo __Pyx_TypeInfo_float = { "float", NULL, sizeof(float), { 0 }, 0, 'R', 0, 0 };
-/* #### Code section: before_global_var ### */
-#define __Pyx_MODULE_NAME "monotonic_align.core"
-extern int __pyx_module_is_main_monotonic_align__core;
-int __pyx_module_is_main_monotonic_align__core = 0;
-
-/* Implementation of "monotonic_align.core" */
-/* #### Code section: global_var ### */
-static PyObject *__pyx_builtin_range;
-static PyObject *__pyx_builtin___import__;
-static PyObject *__pyx_builtin_ValueError;
-static PyObject *__pyx_builtin_MemoryError;
-static PyObject *__pyx_builtin_enumerate;
-static PyObject *__pyx_builtin_TypeError;
-static PyObject *__pyx_builtin_AssertionError;
-static PyObject *__pyx_builtin_Ellipsis;
-static PyObject *__pyx_builtin_id;
-static PyObject *__pyx_builtin_IndexError;
-/* #### Code section: string_decls ### */
-static const char __pyx_k_[] = ": ";
-static const char __pyx_k_O[] = "O";
-static const char __pyx_k_c[] = "c";
-static const char __pyx_k__2[] = ".";
-static const char __pyx_k__3[] = "*";
-static const char __pyx_k__6[] = "'";
-static const char __pyx_k__7[] = ")";
-static const char __pyx_k_gc[] = "gc";
-static const char __pyx_k_id[] = "id";
-static const char __pyx_k__23[] = "?";
-static const char __pyx_k_abc[] = "abc";
-static const char __pyx_k_and[] = " and ";
-static const char __pyx_k_got[] = " (got ";
-static const char __pyx_k_new[] = "__new__";
-static const char __pyx_k_obj[] = "obj";
-static const char __pyx_k_sys[] = "sys";
-static const char __pyx_k_base[] = "base";
-static const char __pyx_k_dict[] = "__dict__";
-static const char __pyx_k_main[] = "__main__";
-static const char __pyx_k_mode[] = "mode";
-static const char __pyx_k_name[] = "name";
-static const char __pyx_k_ndim[] = "ndim";
-static const char __pyx_k_pack[] = "pack";
-static const char __pyx_k_size[] = "size";
-static const char __pyx_k_spec[] = "__spec__";
-static const char __pyx_k_step[] = "step";
-static const char __pyx_k_stop[] = "stop";
-static const char __pyx_k_t_xs[] = "t_xs";
-static const char __pyx_k_t_ys[] = "t_ys";
-static const char __pyx_k_test[] = "__test__";
-static const char __pyx_k_ASCII[] = "ASCII";
-static const char __pyx_k_class[] = "__class__";
-static const char __pyx_k_count[] = "count";
-static const char __pyx_k_error[] = "error";
-static const char __pyx_k_flags[] = "flags";
-static const char __pyx_k_index[] = "index";
-static const char __pyx_k_paths[] = "paths";
-static const char __pyx_k_range[] = "range";
-static const char __pyx_k_shape[] = "shape";
-static const char __pyx_k_start[] = "start";
-static const char __pyx_k_enable[] = "enable";
-static const char __pyx_k_encode[] = "encode";
-static const char __pyx_k_format[] = "format";
-static const char __pyx_k_import[] = "__import__";
-static const char __pyx_k_name_2[] = "__name__";
-static const char __pyx_k_pickle[] = "pickle";
-static const char __pyx_k_reduce[] = "__reduce__";
-static const char __pyx_k_struct[] = "struct";
-static const char __pyx_k_unpack[] = "unpack";
-static const char __pyx_k_update[] = "update";
-static const char __pyx_k_values[] = "values";
-static const char __pyx_k_disable[] = "disable";
-static const char __pyx_k_fortran[] = "fortran";
-static const char __pyx_k_memview[] = "memview";
-static const char __pyx_k_Ellipsis[] = "Ellipsis";
-static const char __pyx_k_Sequence[] = "Sequence";
-static const char __pyx_k_core_pyx[] = "core.pyx";
-static const char __pyx_k_getstate[] = "__getstate__";
-static const char __pyx_k_itemsize[] = "itemsize";
-static const char __pyx_k_pyx_type[] = "__pyx_type";
-static const char __pyx_k_register[] = "register";
-static const char __pyx_k_setstate[] = "__setstate__";
-static const char __pyx_k_TypeError[] = "TypeError";
-static const char __pyx_k_enumerate[] = "enumerate";
-static const char __pyx_k_isenabled[] = "isenabled";
-static const char __pyx_k_pyx_state[] = "__pyx_state";
-static const char __pyx_k_reduce_ex[] = "__reduce_ex__";
-static const char __pyx_k_IndexError[] = "IndexError";
-static const char __pyx_k_ValueError[] = "ValueError";
-static const char __pyx_k_pyx_result[] = "__pyx_result";
-static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__";
-static const char __pyx_k_MemoryError[] = "MemoryError";
-static const char __pyx_k_PickleError[] = "PickleError";
-static const char __pyx_k_collections[] = "collections";
-static const char __pyx_k_initializing[] = "_initializing";
-static const char __pyx_k_is_coroutine[] = "_is_coroutine";
-static const char __pyx_k_pyx_checksum[] = "__pyx_checksum";
-static const char __pyx_k_stringsource[] = "";
-static const char __pyx_k_version_info[] = "version_info";
-static const char __pyx_k_class_getitem[] = "__class_getitem__";
-static const char __pyx_k_reduce_cython[] = "__reduce_cython__";
-static const char __pyx_k_AssertionError[] = "AssertionError";
-static const char __pyx_k_maximum_path_c[] = "maximum_path_c";
-static const char __pyx_k_View_MemoryView[] = "View.MemoryView";
-static const char __pyx_k_allocate_buffer[] = "allocate_buffer";
-static const char __pyx_k_collections_abc[] = "collections.abc";
-static const char __pyx_k_dtype_is_object[] = "dtype_is_object";
-static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError";
-static const char __pyx_k_setstate_cython[] = "__setstate_cython__";
-static const char __pyx_k_pyx_unpickle_Enum[] = "__pyx_unpickle_Enum";
-static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines";
-static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
-static const char __pyx_k_strided_and_direct[] = "";
-static const char __pyx_k_monotonic_align_core[] = "monotonic_align.core";
-static const char __pyx_k_strided_and_indirect[] = "";
-static const char __pyx_k_Invalid_shape_in_axis[] = "Invalid shape in axis ";
-static const char __pyx_k_contiguous_and_direct[] = "";
-static const char __pyx_k_Cannot_index_with_type[] = "Cannot index with type '";
-static const char __pyx_k_MemoryView_of_r_object[] = "";
-static const char __pyx_k_MemoryView_of_r_at_0x_x[] = "";
-static const char __pyx_k_contiguous_and_indirect[] = "";
-static const char __pyx_k_Dimension_d_is_not_direct[] = "Dimension %d is not direct";
-static const char __pyx_k_Index_out_of_bounds_axis_d[] = "Index out of bounds (axis %d)";
-static const char __pyx_k_Step_may_not_be_zero_axis_d[] = "Step may not be zero (axis %d)";
-static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array";
-static const char __pyx_k_unable_to_allocate_array_data[] = "unable to allocate array data.";
-static const char __pyx_k_strided_and_direct_or_indirect[] = "";
-static const char __pyx_k_All_dimensions_preceding_dimensi[] = "All dimensions preceding dimension %d must be indexed and not sliced";
-static const char __pyx_k_Buffer_view_does_not_expose_stri[] = "Buffer view does not expose strides";
-static const char __pyx_k_Can_only_create_a_buffer_that_is[] = "Can only create a buffer that is contiguous in memory.";
-static const char __pyx_k_Cannot_assign_to_read_only_memor[] = "Cannot assign to read-only memoryview";
-static const char __pyx_k_Cannot_create_writable_memory_vi[] = "Cannot create writable memory view from read-only memoryview";
-static const char __pyx_k_Cannot_transpose_memoryview_with[] = "Cannot transpose memoryview with indirect dimensions";
-static const char __pyx_k_Empty_shape_tuple_for_cython_arr[] = "Empty shape tuple for cython.array";
-static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))";
-static const char __pyx_k_Indirect_dimensions_not_supporte[] = "Indirect dimensions not supported";
-static const char __pyx_k_Invalid_mode_expected_c_or_fortr[] = "Invalid mode, expected 'c' or 'fortran', got ";
-static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis ";
-static const char __pyx_k_Unable_to_convert_item_to_object[] = "Unable to convert item to object";
-static const char __pyx_k_got_differing_extents_in_dimensi[] = "got differing extents in dimension ";
-static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__";
-static const char __pyx_k_unable_to_allocate_shape_and_str[] = "unable to allocate shape and strides.";
-/* #### Code section: decls ### */
-static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer); /* proto */
-static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */
-static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self); /* proto */
-static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr); /* proto */
-static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item); /* proto */
-static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /* proto */
-static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
-static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name); /* proto */
-static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */
-static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object); /* proto */
-static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto */
-static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto */
-static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
-static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
-static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */
-static PyObject *__pyx_pf_15monotonic_align_4core_maximum_path_c(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_paths, __Pyx_memviewslice __pyx_v_values, __Pyx_memviewslice __pyx_v_t_ys, __Pyx_memviewslice __pyx_v_t_xs); /* proto */
-static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
-static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
-static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
-static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
-/* #### Code section: late_includes ### */
-/* #### Code section: module_state ### */
-typedef struct {
- PyObject *__pyx_d;
- PyObject *__pyx_b;
- PyObject *__pyx_cython_runtime;
- PyObject *__pyx_empty_tuple;
- PyObject *__pyx_empty_bytes;
- PyObject *__pyx_empty_unicode;
- #ifdef __Pyx_CyFunction_USED
- PyTypeObject *__pyx_CyFunctionType;
- #endif
- #ifdef __Pyx_FusedFunction_USED
- PyTypeObject *__pyx_FusedFunctionType;
- #endif
- #ifdef __Pyx_Generator_USED
- PyTypeObject *__pyx_GeneratorType;
- #endif
- #ifdef __Pyx_IterableCoroutine_USED
- PyTypeObject *__pyx_IterableCoroutineType;
- #endif
- #ifdef __Pyx_Coroutine_USED
- PyTypeObject *__pyx_CoroutineAwaitType;
- #endif
- #ifdef __Pyx_Coroutine_USED
- PyTypeObject *__pyx_CoroutineType;
- #endif
- #if CYTHON_USE_MODULE_STATE
- #endif
- #if CYTHON_USE_MODULE_STATE
- #endif
- #if CYTHON_USE_MODULE_STATE
- #endif
- #if CYTHON_USE_MODULE_STATE
- PyObject *__pyx_type___pyx_array;
- PyObject *__pyx_type___pyx_MemviewEnum;
- PyObject *__pyx_type___pyx_memoryview;
- PyObject *__pyx_type___pyx_memoryviewslice;
- #endif
- PyTypeObject *__pyx_array_type;
- PyTypeObject *__pyx_MemviewEnum_type;
- PyTypeObject *__pyx_memoryview_type;
- PyTypeObject *__pyx_memoryviewslice_type;
- PyObject *__pyx_kp_u_;
- PyObject *__pyx_n_s_ASCII;
- PyObject *__pyx_kp_s_All_dimensions_preceding_dimensi;
- PyObject *__pyx_n_s_AssertionError;
- PyObject *__pyx_kp_s_Buffer_view_does_not_expose_stri;
- PyObject *__pyx_kp_s_Can_only_create_a_buffer_that_is;
- PyObject *__pyx_kp_s_Cannot_assign_to_read_only_memor;
- PyObject *__pyx_kp_s_Cannot_create_writable_memory_vi;
- PyObject *__pyx_kp_u_Cannot_index_with_type;
- PyObject *__pyx_kp_s_Cannot_transpose_memoryview_with;
- PyObject *__pyx_kp_s_Dimension_d_is_not_direct;
- PyObject *__pyx_n_s_Ellipsis;
- PyObject *__pyx_kp_s_Empty_shape_tuple_for_cython_arr;
- PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0;
- PyObject *__pyx_n_s_IndexError;
- PyObject *__pyx_kp_s_Index_out_of_bounds_axis_d;
- PyObject *__pyx_kp_s_Indirect_dimensions_not_supporte;
- PyObject *__pyx_kp_u_Invalid_mode_expected_c_or_fortr;
- PyObject *__pyx_kp_u_Invalid_shape_in_axis;
- PyObject *__pyx_n_s_MemoryError;
- PyObject *__pyx_kp_s_MemoryView_of_r_at_0x_x;
- PyObject *__pyx_kp_s_MemoryView_of_r_object;
- PyObject *__pyx_n_b_O;
- PyObject *__pyx_kp_u_Out_of_bounds_on_buffer_access_a;
- PyObject *__pyx_n_s_PickleError;
- PyObject *__pyx_n_s_Sequence;
- PyObject *__pyx_kp_s_Step_may_not_be_zero_axis_d;
- PyObject *__pyx_n_s_TypeError;
- PyObject *__pyx_kp_s_Unable_to_convert_item_to_object;
- PyObject *__pyx_n_s_ValueError;
- PyObject *__pyx_n_s_View_MemoryView;
- PyObject *__pyx_kp_u__2;
- PyObject *__pyx_n_s__23;
- PyObject *__pyx_n_s__3;
- PyObject *__pyx_kp_u__6;
- PyObject *__pyx_kp_u__7;
- PyObject *__pyx_n_s_abc;
- PyObject *__pyx_n_s_allocate_buffer;
- PyObject *__pyx_kp_u_and;
- PyObject *__pyx_n_s_asyncio_coroutines;
- PyObject *__pyx_n_s_base;
- PyObject *__pyx_n_s_c;
- PyObject *__pyx_n_u_c;
- PyObject *__pyx_n_s_class;
- PyObject *__pyx_n_s_class_getitem;
- PyObject *__pyx_n_s_cline_in_traceback;
- PyObject *__pyx_n_s_collections;
- PyObject *__pyx_kp_s_collections_abc;
- PyObject *__pyx_kp_s_contiguous_and_direct;
- PyObject *__pyx_kp_s_contiguous_and_indirect;
- PyObject *__pyx_kp_s_core_pyx;
- PyObject *__pyx_n_s_count;
- PyObject *__pyx_n_s_dict;
- PyObject *__pyx_kp_u_disable;
- PyObject *__pyx_n_s_dtype_is_object;
- PyObject *__pyx_kp_u_enable;
- PyObject *__pyx_n_s_encode;
- PyObject *__pyx_n_s_enumerate;
- PyObject *__pyx_n_s_error;
- PyObject *__pyx_n_s_flags;
- PyObject *__pyx_n_s_format;
- PyObject *__pyx_n_s_fortran;
- PyObject *__pyx_n_u_fortran;
- PyObject *__pyx_kp_u_gc;
- PyObject *__pyx_n_s_getstate;
- PyObject *__pyx_kp_u_got;
- PyObject *__pyx_kp_u_got_differing_extents_in_dimensi;
- PyObject *__pyx_n_s_id;
- PyObject *__pyx_n_s_import;
- PyObject *__pyx_n_s_index;
- PyObject *__pyx_n_s_initializing;
- PyObject *__pyx_n_s_is_coroutine;
- PyObject *__pyx_kp_u_isenabled;
- PyObject *__pyx_n_s_itemsize;
- PyObject *__pyx_kp_s_itemsize_0_for_cython_array;
- PyObject *__pyx_n_s_main;
- PyObject *__pyx_n_s_maximum_path_c;
- PyObject *__pyx_n_s_memview;
- PyObject *__pyx_n_s_mode;
- PyObject *__pyx_n_s_monotonic_align_core;
- PyObject *__pyx_n_s_name;
- PyObject *__pyx_n_s_name_2;
- PyObject *__pyx_n_s_ndim;
- PyObject *__pyx_n_s_new;
- PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
- PyObject *__pyx_n_s_obj;
- PyObject *__pyx_n_s_pack;
- PyObject *__pyx_n_s_paths;
- PyObject *__pyx_n_s_pickle;
- PyObject *__pyx_n_s_pyx_PickleError;
- PyObject *__pyx_n_s_pyx_checksum;
- PyObject *__pyx_n_s_pyx_result;
- PyObject *__pyx_n_s_pyx_state;
- PyObject *__pyx_n_s_pyx_type;
- PyObject *__pyx_n_s_pyx_unpickle_Enum;
- PyObject *__pyx_n_s_pyx_vtable;
- PyObject *__pyx_n_s_range;
- PyObject *__pyx_n_s_reduce;
- PyObject *__pyx_n_s_reduce_cython;
- PyObject *__pyx_n_s_reduce_ex;
- PyObject *__pyx_n_s_register;
- PyObject *__pyx_n_s_setstate;
- PyObject *__pyx_n_s_setstate_cython;
- PyObject *__pyx_n_s_shape;
- PyObject *__pyx_n_s_size;
- PyObject *__pyx_n_s_spec;
- PyObject *__pyx_n_s_start;
- PyObject *__pyx_n_s_step;
- PyObject *__pyx_n_s_stop;
- PyObject *__pyx_kp_s_strided_and_direct;
- PyObject *__pyx_kp_s_strided_and_direct_or_indirect;
- PyObject *__pyx_kp_s_strided_and_indirect;
- PyObject *__pyx_kp_s_stringsource;
- PyObject *__pyx_n_s_struct;
- PyObject *__pyx_n_s_sys;
- PyObject *__pyx_n_s_t_xs;
- PyObject *__pyx_n_s_t_ys;
- PyObject *__pyx_n_s_test;
- PyObject *__pyx_kp_s_unable_to_allocate_array_data;
- PyObject *__pyx_kp_s_unable_to_allocate_shape_and_str;
- PyObject *__pyx_n_s_unpack;
- PyObject *__pyx_n_s_update;
- PyObject *__pyx_n_s_values;
- PyObject *__pyx_n_s_version_info;
- PyObject *__pyx_int_0;
- PyObject *__pyx_int_1;
- PyObject *__pyx_int_3;
- PyObject *__pyx_int_112105877;
- PyObject *__pyx_int_136983863;
- PyObject *__pyx_int_184977713;
- PyObject *__pyx_int_neg_1;
- float __pyx_k__9;
- PyObject *__pyx_slice__5;
- PyObject *__pyx_tuple__4;
- PyObject *__pyx_tuple__8;
- PyObject *__pyx_tuple__10;
- PyObject *__pyx_tuple__11;
- PyObject *__pyx_tuple__12;
- PyObject *__pyx_tuple__13;
- PyObject *__pyx_tuple__14;
- PyObject *__pyx_tuple__15;
- PyObject *__pyx_tuple__16;
- PyObject *__pyx_tuple__17;
- PyObject *__pyx_tuple__18;
- PyObject *__pyx_tuple__19;
- PyObject *__pyx_tuple__21;
- PyObject *__pyx_codeobj__20;
- PyObject *__pyx_codeobj__22;
-} __pyx_mstate;
-
-#if CYTHON_USE_MODULE_STATE
-#ifdef __cplusplus
-namespace {
- extern struct PyModuleDef __pyx_moduledef;
-} /* anonymous namespace */
-#else
-static struct PyModuleDef __pyx_moduledef;
-#endif
-
-#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o))
-
-#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef)))
-
-#define __pyx_m (PyState_FindModule(&__pyx_moduledef))
-#else
-static __pyx_mstate __pyx_mstate_global_static =
-#ifdef __cplusplus
- {};
-#else
- {0};
-#endif
-static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static;
-#endif
-/* #### Code section: module_state_clear ### */
-#if CYTHON_USE_MODULE_STATE
-static int __pyx_m_clear(PyObject *m) {
- __pyx_mstate *clear_module_state = __pyx_mstate(m);
- if (!clear_module_state) return 0;
- Py_CLEAR(clear_module_state->__pyx_d);
- Py_CLEAR(clear_module_state->__pyx_b);
- Py_CLEAR(clear_module_state->__pyx_cython_runtime);
- Py_CLEAR(clear_module_state->__pyx_empty_tuple);
- Py_CLEAR(clear_module_state->__pyx_empty_bytes);
- Py_CLEAR(clear_module_state->__pyx_empty_unicode);
- #ifdef __Pyx_CyFunction_USED
- Py_CLEAR(clear_module_state->__pyx_CyFunctionType);
- #endif
- #ifdef __Pyx_FusedFunction_USED
- Py_CLEAR(clear_module_state->__pyx_FusedFunctionType);
- #endif
- Py_CLEAR(clear_module_state->__pyx_array_type);
- Py_CLEAR(clear_module_state->__pyx_type___pyx_array);
- Py_CLEAR(clear_module_state->__pyx_MemviewEnum_type);
- Py_CLEAR(clear_module_state->__pyx_type___pyx_MemviewEnum);
- Py_CLEAR(clear_module_state->__pyx_memoryview_type);
- Py_CLEAR(clear_module_state->__pyx_type___pyx_memoryview);
- Py_CLEAR(clear_module_state->__pyx_memoryviewslice_type);
- Py_CLEAR(clear_module_state->__pyx_type___pyx_memoryviewslice);
- Py_CLEAR(clear_module_state->__pyx_kp_u_);
- Py_CLEAR(clear_module_state->__pyx_n_s_ASCII);
- Py_CLEAR(clear_module_state->__pyx_kp_s_All_dimensions_preceding_dimensi);
- Py_CLEAR(clear_module_state->__pyx_n_s_AssertionError);
- Py_CLEAR(clear_module_state->__pyx_kp_s_Buffer_view_does_not_expose_stri);
- Py_CLEAR(clear_module_state->__pyx_kp_s_Can_only_create_a_buffer_that_is);
- Py_CLEAR(clear_module_state->__pyx_kp_s_Cannot_assign_to_read_only_memor);
- Py_CLEAR(clear_module_state->__pyx_kp_s_Cannot_create_writable_memory_vi);
- Py_CLEAR(clear_module_state->__pyx_kp_u_Cannot_index_with_type);
- Py_CLEAR(clear_module_state->__pyx_kp_s_Cannot_transpose_memoryview_with);
- Py_CLEAR(clear_module_state->__pyx_kp_s_Dimension_d_is_not_direct);
- Py_CLEAR(clear_module_state->__pyx_n_s_Ellipsis);
- Py_CLEAR(clear_module_state->__pyx_kp_s_Empty_shape_tuple_for_cython_arr);
- Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0);
- Py_CLEAR(clear_module_state->__pyx_n_s_IndexError);
- Py_CLEAR(clear_module_state->__pyx_kp_s_Index_out_of_bounds_axis_d);
- Py_CLEAR(clear_module_state->__pyx_kp_s_Indirect_dimensions_not_supporte);
- Py_CLEAR(clear_module_state->__pyx_kp_u_Invalid_mode_expected_c_or_fortr);
- Py_CLEAR(clear_module_state->__pyx_kp_u_Invalid_shape_in_axis);
- Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError);
- Py_CLEAR(clear_module_state->__pyx_kp_s_MemoryView_of_r_at_0x_x);
- Py_CLEAR(clear_module_state->__pyx_kp_s_MemoryView_of_r_object);
- Py_CLEAR(clear_module_state->__pyx_n_b_O);
- Py_CLEAR(clear_module_state->__pyx_kp_u_Out_of_bounds_on_buffer_access_a);
- Py_CLEAR(clear_module_state->__pyx_n_s_PickleError);
- Py_CLEAR(clear_module_state->__pyx_n_s_Sequence);
- Py_CLEAR(clear_module_state->__pyx_kp_s_Step_may_not_be_zero_axis_d);
- Py_CLEAR(clear_module_state->__pyx_n_s_TypeError);
- Py_CLEAR(clear_module_state->__pyx_kp_s_Unable_to_convert_item_to_object);
- Py_CLEAR(clear_module_state->__pyx_n_s_ValueError);
- Py_CLEAR(clear_module_state->__pyx_n_s_View_MemoryView);
- Py_CLEAR(clear_module_state->__pyx_kp_u__2);
- Py_CLEAR(clear_module_state->__pyx_n_s__23);
- Py_CLEAR(clear_module_state->__pyx_n_s__3);
- Py_CLEAR(clear_module_state->__pyx_kp_u__6);
- Py_CLEAR(clear_module_state->__pyx_kp_u__7);
- Py_CLEAR(clear_module_state->__pyx_n_s_abc);
- Py_CLEAR(clear_module_state->__pyx_n_s_allocate_buffer);
- Py_CLEAR(clear_module_state->__pyx_kp_u_and);
- Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines);
- Py_CLEAR(clear_module_state->__pyx_n_s_base);
- Py_CLEAR(clear_module_state->__pyx_n_s_c);
- Py_CLEAR(clear_module_state->__pyx_n_u_c);
- Py_CLEAR(clear_module_state->__pyx_n_s_class);
- Py_CLEAR(clear_module_state->__pyx_n_s_class_getitem);
- Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback);
- Py_CLEAR(clear_module_state->__pyx_n_s_collections);
- Py_CLEAR(clear_module_state->__pyx_kp_s_collections_abc);
- Py_CLEAR(clear_module_state->__pyx_kp_s_contiguous_and_direct);
- Py_CLEAR(clear_module_state->__pyx_kp_s_contiguous_and_indirect);
- Py_CLEAR(clear_module_state->__pyx_kp_s_core_pyx);
- Py_CLEAR(clear_module_state->__pyx_n_s_count);
- Py_CLEAR(clear_module_state->__pyx_n_s_dict);
- Py_CLEAR(clear_module_state->__pyx_kp_u_disable);
- Py_CLEAR(clear_module_state->__pyx_n_s_dtype_is_object);
- Py_CLEAR(clear_module_state->__pyx_kp_u_enable);
- Py_CLEAR(clear_module_state->__pyx_n_s_encode);
- Py_CLEAR(clear_module_state->__pyx_n_s_enumerate);
- Py_CLEAR(clear_module_state->__pyx_n_s_error);
- Py_CLEAR(clear_module_state->__pyx_n_s_flags);
- Py_CLEAR(clear_module_state->__pyx_n_s_format);
- Py_CLEAR(clear_module_state->__pyx_n_s_fortran);
- Py_CLEAR(clear_module_state->__pyx_n_u_fortran);
- Py_CLEAR(clear_module_state->__pyx_kp_u_gc);
- Py_CLEAR(clear_module_state->__pyx_n_s_getstate);
- Py_CLEAR(clear_module_state->__pyx_kp_u_got);
- Py_CLEAR(clear_module_state->__pyx_kp_u_got_differing_extents_in_dimensi);
- Py_CLEAR(clear_module_state->__pyx_n_s_id);
- Py_CLEAR(clear_module_state->__pyx_n_s_import);
- Py_CLEAR(clear_module_state->__pyx_n_s_index);
- Py_CLEAR(clear_module_state->__pyx_n_s_initializing);
- Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine);
- Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled);
- Py_CLEAR(clear_module_state->__pyx_n_s_itemsize);
- Py_CLEAR(clear_module_state->__pyx_kp_s_itemsize_0_for_cython_array);
- Py_CLEAR(clear_module_state->__pyx_n_s_main);
- Py_CLEAR(clear_module_state->__pyx_n_s_maximum_path_c);
- Py_CLEAR(clear_module_state->__pyx_n_s_memview);
- Py_CLEAR(clear_module_state->__pyx_n_s_mode);
- Py_CLEAR(clear_module_state->__pyx_n_s_monotonic_align_core);
- Py_CLEAR(clear_module_state->__pyx_n_s_name);
- Py_CLEAR(clear_module_state->__pyx_n_s_name_2);
- Py_CLEAR(clear_module_state->__pyx_n_s_ndim);
- Py_CLEAR(clear_module_state->__pyx_n_s_new);
- Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
- Py_CLEAR(clear_module_state->__pyx_n_s_obj);
- Py_CLEAR(clear_module_state->__pyx_n_s_pack);
- Py_CLEAR(clear_module_state->__pyx_n_s_paths);
- Py_CLEAR(clear_module_state->__pyx_n_s_pickle);
- Py_CLEAR(clear_module_state->__pyx_n_s_pyx_PickleError);
- Py_CLEAR(clear_module_state->__pyx_n_s_pyx_checksum);
- Py_CLEAR(clear_module_state->__pyx_n_s_pyx_result);
- Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state);
- Py_CLEAR(clear_module_state->__pyx_n_s_pyx_type);
- Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Enum);
- Py_CLEAR(clear_module_state->__pyx_n_s_pyx_vtable);
- Py_CLEAR(clear_module_state->__pyx_n_s_range);
- Py_CLEAR(clear_module_state->__pyx_n_s_reduce);
- Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython);
- Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex);
- Py_CLEAR(clear_module_state->__pyx_n_s_register);
- Py_CLEAR(clear_module_state->__pyx_n_s_setstate);
- Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython);
- Py_CLEAR(clear_module_state->__pyx_n_s_shape);
- Py_CLEAR(clear_module_state->__pyx_n_s_size);
- Py_CLEAR(clear_module_state->__pyx_n_s_spec);
- Py_CLEAR(clear_module_state->__pyx_n_s_start);
- Py_CLEAR(clear_module_state->__pyx_n_s_step);
- Py_CLEAR(clear_module_state->__pyx_n_s_stop);
- Py_CLEAR(clear_module_state->__pyx_kp_s_strided_and_direct);
- Py_CLEAR(clear_module_state->__pyx_kp_s_strided_and_direct_or_indirect);
- Py_CLEAR(clear_module_state->__pyx_kp_s_strided_and_indirect);
- Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource);
- Py_CLEAR(clear_module_state->__pyx_n_s_struct);
- Py_CLEAR(clear_module_state->__pyx_n_s_sys);
- Py_CLEAR(clear_module_state->__pyx_n_s_t_xs);
- Py_CLEAR(clear_module_state->__pyx_n_s_t_ys);
- Py_CLEAR(clear_module_state->__pyx_n_s_test);
- Py_CLEAR(clear_module_state->__pyx_kp_s_unable_to_allocate_array_data);
- Py_CLEAR(clear_module_state->__pyx_kp_s_unable_to_allocate_shape_and_str);
- Py_CLEAR(clear_module_state->__pyx_n_s_unpack);
- Py_CLEAR(clear_module_state->__pyx_n_s_update);
- Py_CLEAR(clear_module_state->__pyx_n_s_values);
- Py_CLEAR(clear_module_state->__pyx_n_s_version_info);
- Py_CLEAR(clear_module_state->__pyx_int_0);
- Py_CLEAR(clear_module_state->__pyx_int_1);
- Py_CLEAR(clear_module_state->__pyx_int_3);
- Py_CLEAR(clear_module_state->__pyx_int_112105877);
- Py_CLEAR(clear_module_state->__pyx_int_136983863);
- Py_CLEAR(clear_module_state->__pyx_int_184977713);
- Py_CLEAR(clear_module_state->__pyx_int_neg_1);
- Py_CLEAR(clear_module_state->__pyx_slice__5);
- Py_CLEAR(clear_module_state->__pyx_tuple__4);
- Py_CLEAR(clear_module_state->__pyx_tuple__8);
- Py_CLEAR(clear_module_state->__pyx_tuple__10);
- Py_CLEAR(clear_module_state->__pyx_tuple__11);
- Py_CLEAR(clear_module_state->__pyx_tuple__12);
- Py_CLEAR(clear_module_state->__pyx_tuple__13);
- Py_CLEAR(clear_module_state->__pyx_tuple__14);
- Py_CLEAR(clear_module_state->__pyx_tuple__15);
- Py_CLEAR(clear_module_state->__pyx_tuple__16);
- Py_CLEAR(clear_module_state->__pyx_tuple__17);
- Py_CLEAR(clear_module_state->__pyx_tuple__18);
- Py_CLEAR(clear_module_state->__pyx_tuple__19);
- Py_CLEAR(clear_module_state->__pyx_tuple__21);
- Py_CLEAR(clear_module_state->__pyx_codeobj__20);
- Py_CLEAR(clear_module_state->__pyx_codeobj__22);
- return 0;
-}
-#endif
-/* #### Code section: module_state_traverse ### */
-#if CYTHON_USE_MODULE_STATE
-static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
- __pyx_mstate *traverse_module_state = __pyx_mstate(m);
- if (!traverse_module_state) return 0;
- Py_VISIT(traverse_module_state->__pyx_d);
- Py_VISIT(traverse_module_state->__pyx_b);
- Py_VISIT(traverse_module_state->__pyx_cython_runtime);
- Py_VISIT(traverse_module_state->__pyx_empty_tuple);
- Py_VISIT(traverse_module_state->__pyx_empty_bytes);
- Py_VISIT(traverse_module_state->__pyx_empty_unicode);
- #ifdef __Pyx_CyFunction_USED
- Py_VISIT(traverse_module_state->__pyx_CyFunctionType);
- #endif
- #ifdef __Pyx_FusedFunction_USED
- Py_VISIT(traverse_module_state->__pyx_FusedFunctionType);
- #endif
- Py_VISIT(traverse_module_state->__pyx_array_type);
- Py_VISIT(traverse_module_state->__pyx_type___pyx_array);
- Py_VISIT(traverse_module_state->__pyx_MemviewEnum_type);
- Py_VISIT(traverse_module_state->__pyx_type___pyx_MemviewEnum);
- Py_VISIT(traverse_module_state->__pyx_memoryview_type);
- Py_VISIT(traverse_module_state->__pyx_type___pyx_memoryview);
- Py_VISIT(traverse_module_state->__pyx_memoryviewslice_type);
- Py_VISIT(traverse_module_state->__pyx_type___pyx_memoryviewslice);
- Py_VISIT(traverse_module_state->__pyx_kp_u_);
- Py_VISIT(traverse_module_state->__pyx_n_s_ASCII);
- Py_VISIT(traverse_module_state->__pyx_kp_s_All_dimensions_preceding_dimensi);
- Py_VISIT(traverse_module_state->__pyx_n_s_AssertionError);
- Py_VISIT(traverse_module_state->__pyx_kp_s_Buffer_view_does_not_expose_stri);
- Py_VISIT(traverse_module_state->__pyx_kp_s_Can_only_create_a_buffer_that_is);
- Py_VISIT(traverse_module_state->__pyx_kp_s_Cannot_assign_to_read_only_memor);
- Py_VISIT(traverse_module_state->__pyx_kp_s_Cannot_create_writable_memory_vi);
- Py_VISIT(traverse_module_state->__pyx_kp_u_Cannot_index_with_type);
- Py_VISIT(traverse_module_state->__pyx_kp_s_Cannot_transpose_memoryview_with);
- Py_VISIT(traverse_module_state->__pyx_kp_s_Dimension_d_is_not_direct);
- Py_VISIT(traverse_module_state->__pyx_n_s_Ellipsis);
- Py_VISIT(traverse_module_state->__pyx_kp_s_Empty_shape_tuple_for_cython_arr);
- Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0);
- Py_VISIT(traverse_module_state->__pyx_n_s_IndexError);
- Py_VISIT(traverse_module_state->__pyx_kp_s_Index_out_of_bounds_axis_d);
- Py_VISIT(traverse_module_state->__pyx_kp_s_Indirect_dimensions_not_supporte);
- Py_VISIT(traverse_module_state->__pyx_kp_u_Invalid_mode_expected_c_or_fortr);
- Py_VISIT(traverse_module_state->__pyx_kp_u_Invalid_shape_in_axis);
- Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError);
- Py_VISIT(traverse_module_state->__pyx_kp_s_MemoryView_of_r_at_0x_x);
- Py_VISIT(traverse_module_state->__pyx_kp_s_MemoryView_of_r_object);
- Py_VISIT(traverse_module_state->__pyx_n_b_O);
- Py_VISIT(traverse_module_state->__pyx_kp_u_Out_of_bounds_on_buffer_access_a);
- Py_VISIT(traverse_module_state->__pyx_n_s_PickleError);
- Py_VISIT(traverse_module_state->__pyx_n_s_Sequence);
- Py_VISIT(traverse_module_state->__pyx_kp_s_Step_may_not_be_zero_axis_d);
- Py_VISIT(traverse_module_state->__pyx_n_s_TypeError);
- Py_VISIT(traverse_module_state->__pyx_kp_s_Unable_to_convert_item_to_object);
- Py_VISIT(traverse_module_state->__pyx_n_s_ValueError);
- Py_VISIT(traverse_module_state->__pyx_n_s_View_MemoryView);
- Py_VISIT(traverse_module_state->__pyx_kp_u__2);
- Py_VISIT(traverse_module_state->__pyx_n_s__23);
- Py_VISIT(traverse_module_state->__pyx_n_s__3);
- Py_VISIT(traverse_module_state->__pyx_kp_u__6);
- Py_VISIT(traverse_module_state->__pyx_kp_u__7);
- Py_VISIT(traverse_module_state->__pyx_n_s_abc);
- Py_VISIT(traverse_module_state->__pyx_n_s_allocate_buffer);
- Py_VISIT(traverse_module_state->__pyx_kp_u_and);
- Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines);
- Py_VISIT(traverse_module_state->__pyx_n_s_base);
- Py_VISIT(traverse_module_state->__pyx_n_s_c);
- Py_VISIT(traverse_module_state->__pyx_n_u_c);
- Py_VISIT(traverse_module_state->__pyx_n_s_class);
- Py_VISIT(traverse_module_state->__pyx_n_s_class_getitem);
- Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback);
- Py_VISIT(traverse_module_state->__pyx_n_s_collections);
- Py_VISIT(traverse_module_state->__pyx_kp_s_collections_abc);
- Py_VISIT(traverse_module_state->__pyx_kp_s_contiguous_and_direct);
- Py_VISIT(traverse_module_state->__pyx_kp_s_contiguous_and_indirect);
- Py_VISIT(traverse_module_state->__pyx_kp_s_core_pyx);
- Py_VISIT(traverse_module_state->__pyx_n_s_count);
- Py_VISIT(traverse_module_state->__pyx_n_s_dict);
- Py_VISIT(traverse_module_state->__pyx_kp_u_disable);
- Py_VISIT(traverse_module_state->__pyx_n_s_dtype_is_object);
- Py_VISIT(traverse_module_state->__pyx_kp_u_enable);
- Py_VISIT(traverse_module_state->__pyx_n_s_encode);
- Py_VISIT(traverse_module_state->__pyx_n_s_enumerate);
- Py_VISIT(traverse_module_state->__pyx_n_s_error);
- Py_VISIT(traverse_module_state->__pyx_n_s_flags);
- Py_VISIT(traverse_module_state->__pyx_n_s_format);
- Py_VISIT(traverse_module_state->__pyx_n_s_fortran);
- Py_VISIT(traverse_module_state->__pyx_n_u_fortran);
- Py_VISIT(traverse_module_state->__pyx_kp_u_gc);
- Py_VISIT(traverse_module_state->__pyx_n_s_getstate);
- Py_VISIT(traverse_module_state->__pyx_kp_u_got);
- Py_VISIT(traverse_module_state->__pyx_kp_u_got_differing_extents_in_dimensi);
- Py_VISIT(traverse_module_state->__pyx_n_s_id);
- Py_VISIT(traverse_module_state->__pyx_n_s_import);
- Py_VISIT(traverse_module_state->__pyx_n_s_index);
- Py_VISIT(traverse_module_state->__pyx_n_s_initializing);
- Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine);
- Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled);
- Py_VISIT(traverse_module_state->__pyx_n_s_itemsize);
- Py_VISIT(traverse_module_state->__pyx_kp_s_itemsize_0_for_cython_array);
- Py_VISIT(traverse_module_state->__pyx_n_s_main);
- Py_VISIT(traverse_module_state->__pyx_n_s_maximum_path_c);
- Py_VISIT(traverse_module_state->__pyx_n_s_memview);
- Py_VISIT(traverse_module_state->__pyx_n_s_mode);
- Py_VISIT(traverse_module_state->__pyx_n_s_monotonic_align_core);
- Py_VISIT(traverse_module_state->__pyx_n_s_name);
- Py_VISIT(traverse_module_state->__pyx_n_s_name_2);
- Py_VISIT(traverse_module_state->__pyx_n_s_ndim);
- Py_VISIT(traverse_module_state->__pyx_n_s_new);
- Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
- Py_VISIT(traverse_module_state->__pyx_n_s_obj);
- Py_VISIT(traverse_module_state->__pyx_n_s_pack);
- Py_VISIT(traverse_module_state->__pyx_n_s_paths);
- Py_VISIT(traverse_module_state->__pyx_n_s_pickle);
- Py_VISIT(traverse_module_state->__pyx_n_s_pyx_PickleError);
- Py_VISIT(traverse_module_state->__pyx_n_s_pyx_checksum);
- Py_VISIT(traverse_module_state->__pyx_n_s_pyx_result);
- Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state);
- Py_VISIT(traverse_module_state->__pyx_n_s_pyx_type);
- Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Enum);
- Py_VISIT(traverse_module_state->__pyx_n_s_pyx_vtable);
- Py_VISIT(traverse_module_state->__pyx_n_s_range);
- Py_VISIT(traverse_module_state->__pyx_n_s_reduce);
- Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython);
- Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex);
- Py_VISIT(traverse_module_state->__pyx_n_s_register);
- Py_VISIT(traverse_module_state->__pyx_n_s_setstate);
- Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython);
- Py_VISIT(traverse_module_state->__pyx_n_s_shape);
- Py_VISIT(traverse_module_state->__pyx_n_s_size);
- Py_VISIT(traverse_module_state->__pyx_n_s_spec);
- Py_VISIT(traverse_module_state->__pyx_n_s_start);
- Py_VISIT(traverse_module_state->__pyx_n_s_step);
- Py_VISIT(traverse_module_state->__pyx_n_s_stop);
- Py_VISIT(traverse_module_state->__pyx_kp_s_strided_and_direct);
- Py_VISIT(traverse_module_state->__pyx_kp_s_strided_and_direct_or_indirect);
- Py_VISIT(traverse_module_state->__pyx_kp_s_strided_and_indirect);
- Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource);
- Py_VISIT(traverse_module_state->__pyx_n_s_struct);
- Py_VISIT(traverse_module_state->__pyx_n_s_sys);
- Py_VISIT(traverse_module_state->__pyx_n_s_t_xs);
- Py_VISIT(traverse_module_state->__pyx_n_s_t_ys);
- Py_VISIT(traverse_module_state->__pyx_n_s_test);
- Py_VISIT(traverse_module_state->__pyx_kp_s_unable_to_allocate_array_data);
- Py_VISIT(traverse_module_state->__pyx_kp_s_unable_to_allocate_shape_and_str);
- Py_VISIT(traverse_module_state->__pyx_n_s_unpack);
- Py_VISIT(traverse_module_state->__pyx_n_s_update);
- Py_VISIT(traverse_module_state->__pyx_n_s_values);
- Py_VISIT(traverse_module_state->__pyx_n_s_version_info);
- Py_VISIT(traverse_module_state->__pyx_int_0);
- Py_VISIT(traverse_module_state->__pyx_int_1);
- Py_VISIT(traverse_module_state->__pyx_int_3);
- Py_VISIT(traverse_module_state->__pyx_int_112105877);
- Py_VISIT(traverse_module_state->__pyx_int_136983863);
- Py_VISIT(traverse_module_state->__pyx_int_184977713);
- Py_VISIT(traverse_module_state->__pyx_int_neg_1);
- Py_VISIT(traverse_module_state->__pyx_slice__5);
- Py_VISIT(traverse_module_state->__pyx_tuple__4);
- Py_VISIT(traverse_module_state->__pyx_tuple__8);
- Py_VISIT(traverse_module_state->__pyx_tuple__10);
- Py_VISIT(traverse_module_state->__pyx_tuple__11);
- Py_VISIT(traverse_module_state->__pyx_tuple__12);
- Py_VISIT(traverse_module_state->__pyx_tuple__13);
- Py_VISIT(traverse_module_state->__pyx_tuple__14);
- Py_VISIT(traverse_module_state->__pyx_tuple__15);
- Py_VISIT(traverse_module_state->__pyx_tuple__16);
- Py_VISIT(traverse_module_state->__pyx_tuple__17);
- Py_VISIT(traverse_module_state->__pyx_tuple__18);
- Py_VISIT(traverse_module_state->__pyx_tuple__19);
- Py_VISIT(traverse_module_state->__pyx_tuple__21);
- Py_VISIT(traverse_module_state->__pyx_codeobj__20);
- Py_VISIT(traverse_module_state->__pyx_codeobj__22);
- return 0;
-}
-#endif
-/* #### Code section: module_state_defines ### */
-#define __pyx_d __pyx_mstate_global->__pyx_d
-#define __pyx_b __pyx_mstate_global->__pyx_b
-#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime
-#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple
-#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes
-#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode
-#ifdef __Pyx_CyFunction_USED
-#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType
-#endif
-#ifdef __Pyx_FusedFunction_USED
-#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType
-#endif
-#ifdef __Pyx_Generator_USED
-#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType
-#endif
-#ifdef __Pyx_IterableCoroutine_USED
-#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType
-#endif
-#ifdef __Pyx_Coroutine_USED
-#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType
-#endif
-#ifdef __Pyx_Coroutine_USED
-#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType
-#endif
-#if CYTHON_USE_MODULE_STATE
-#endif
-#if CYTHON_USE_MODULE_STATE
-#endif
-#if CYTHON_USE_MODULE_STATE
-#endif
-#if CYTHON_USE_MODULE_STATE
-#define __pyx_type___pyx_array __pyx_mstate_global->__pyx_type___pyx_array
-#define __pyx_type___pyx_MemviewEnum __pyx_mstate_global->__pyx_type___pyx_MemviewEnum
-#define __pyx_type___pyx_memoryview __pyx_mstate_global->__pyx_type___pyx_memoryview
-#define __pyx_type___pyx_memoryviewslice __pyx_mstate_global->__pyx_type___pyx_memoryviewslice
-#endif
-#define __pyx_array_type __pyx_mstate_global->__pyx_array_type
-#define __pyx_MemviewEnum_type __pyx_mstate_global->__pyx_MemviewEnum_type
-#define __pyx_memoryview_type __pyx_mstate_global->__pyx_memoryview_type
-#define __pyx_memoryviewslice_type __pyx_mstate_global->__pyx_memoryviewslice_type
-#define __pyx_kp_u_ __pyx_mstate_global->__pyx_kp_u_
-#define __pyx_n_s_ASCII __pyx_mstate_global->__pyx_n_s_ASCII
-#define __pyx_kp_s_All_dimensions_preceding_dimensi __pyx_mstate_global->__pyx_kp_s_All_dimensions_preceding_dimensi
-#define __pyx_n_s_AssertionError __pyx_mstate_global->__pyx_n_s_AssertionError
-#define __pyx_kp_s_Buffer_view_does_not_expose_stri __pyx_mstate_global->__pyx_kp_s_Buffer_view_does_not_expose_stri
-#define __pyx_kp_s_Can_only_create_a_buffer_that_is __pyx_mstate_global->__pyx_kp_s_Can_only_create_a_buffer_that_is
-#define __pyx_kp_s_Cannot_assign_to_read_only_memor __pyx_mstate_global->__pyx_kp_s_Cannot_assign_to_read_only_memor
-#define __pyx_kp_s_Cannot_create_writable_memory_vi __pyx_mstate_global->__pyx_kp_s_Cannot_create_writable_memory_vi
-#define __pyx_kp_u_Cannot_index_with_type __pyx_mstate_global->__pyx_kp_u_Cannot_index_with_type
-#define __pyx_kp_s_Cannot_transpose_memoryview_with __pyx_mstate_global->__pyx_kp_s_Cannot_transpose_memoryview_with
-#define __pyx_kp_s_Dimension_d_is_not_direct __pyx_mstate_global->__pyx_kp_s_Dimension_d_is_not_direct
-#define __pyx_n_s_Ellipsis __pyx_mstate_global->__pyx_n_s_Ellipsis
-#define __pyx_kp_s_Empty_shape_tuple_for_cython_arr __pyx_mstate_global->__pyx_kp_s_Empty_shape_tuple_for_cython_arr
-#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0
-#define __pyx_n_s_IndexError __pyx_mstate_global->__pyx_n_s_IndexError
-#define __pyx_kp_s_Index_out_of_bounds_axis_d __pyx_mstate_global->__pyx_kp_s_Index_out_of_bounds_axis_d
-#define __pyx_kp_s_Indirect_dimensions_not_supporte __pyx_mstate_global->__pyx_kp_s_Indirect_dimensions_not_supporte
-#define __pyx_kp_u_Invalid_mode_expected_c_or_fortr __pyx_mstate_global->__pyx_kp_u_Invalid_mode_expected_c_or_fortr
-#define __pyx_kp_u_Invalid_shape_in_axis __pyx_mstate_global->__pyx_kp_u_Invalid_shape_in_axis
-#define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError
-#define __pyx_kp_s_MemoryView_of_r_at_0x_x __pyx_mstate_global->__pyx_kp_s_MemoryView_of_r_at_0x_x
-#define __pyx_kp_s_MemoryView_of_r_object __pyx_mstate_global->__pyx_kp_s_MemoryView_of_r_object
-#define __pyx_n_b_O __pyx_mstate_global->__pyx_n_b_O
-#define __pyx_kp_u_Out_of_bounds_on_buffer_access_a __pyx_mstate_global->__pyx_kp_u_Out_of_bounds_on_buffer_access_a
-#define __pyx_n_s_PickleError __pyx_mstate_global->__pyx_n_s_PickleError
-#define __pyx_n_s_Sequence __pyx_mstate_global->__pyx_n_s_Sequence
-#define __pyx_kp_s_Step_may_not_be_zero_axis_d __pyx_mstate_global->__pyx_kp_s_Step_may_not_be_zero_axis_d
-#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError
-#define __pyx_kp_s_Unable_to_convert_item_to_object __pyx_mstate_global->__pyx_kp_s_Unable_to_convert_item_to_object
-#define __pyx_n_s_ValueError __pyx_mstate_global->__pyx_n_s_ValueError
-#define __pyx_n_s_View_MemoryView __pyx_mstate_global->__pyx_n_s_View_MemoryView
-#define __pyx_kp_u__2 __pyx_mstate_global->__pyx_kp_u__2
-#define __pyx_n_s__23 __pyx_mstate_global->__pyx_n_s__23
-#define __pyx_n_s__3 __pyx_mstate_global->__pyx_n_s__3
-#define __pyx_kp_u__6 __pyx_mstate_global->__pyx_kp_u__6
-#define __pyx_kp_u__7 __pyx_mstate_global->__pyx_kp_u__7
-#define __pyx_n_s_abc __pyx_mstate_global->__pyx_n_s_abc
-#define __pyx_n_s_allocate_buffer __pyx_mstate_global->__pyx_n_s_allocate_buffer
-#define __pyx_kp_u_and __pyx_mstate_global->__pyx_kp_u_and
-#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines
-#define __pyx_n_s_base __pyx_mstate_global->__pyx_n_s_base
-#define __pyx_n_s_c __pyx_mstate_global->__pyx_n_s_c
-#define __pyx_n_u_c __pyx_mstate_global->__pyx_n_u_c
-#define __pyx_n_s_class __pyx_mstate_global->__pyx_n_s_class
-#define __pyx_n_s_class_getitem __pyx_mstate_global->__pyx_n_s_class_getitem
-#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback
-#define __pyx_n_s_collections __pyx_mstate_global->__pyx_n_s_collections
-#define __pyx_kp_s_collections_abc __pyx_mstate_global->__pyx_kp_s_collections_abc
-#define __pyx_kp_s_contiguous_and_direct __pyx_mstate_global->__pyx_kp_s_contiguous_and_direct
-#define __pyx_kp_s_contiguous_and_indirect __pyx_mstate_global->__pyx_kp_s_contiguous_and_indirect
-#define __pyx_kp_s_core_pyx __pyx_mstate_global->__pyx_kp_s_core_pyx
-#define __pyx_n_s_count __pyx_mstate_global->__pyx_n_s_count
-#define __pyx_n_s_dict __pyx_mstate_global->__pyx_n_s_dict
-#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable
-#define __pyx_n_s_dtype_is_object __pyx_mstate_global->__pyx_n_s_dtype_is_object
-#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable
-#define __pyx_n_s_encode __pyx_mstate_global->__pyx_n_s_encode
-#define __pyx_n_s_enumerate __pyx_mstate_global->__pyx_n_s_enumerate
-#define __pyx_n_s_error __pyx_mstate_global->__pyx_n_s_error
-#define __pyx_n_s_flags __pyx_mstate_global->__pyx_n_s_flags
-#define __pyx_n_s_format __pyx_mstate_global->__pyx_n_s_format
-#define __pyx_n_s_fortran __pyx_mstate_global->__pyx_n_s_fortran
-#define __pyx_n_u_fortran __pyx_mstate_global->__pyx_n_u_fortran
-#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc
-#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate
-#define __pyx_kp_u_got __pyx_mstate_global->__pyx_kp_u_got
-#define __pyx_kp_u_got_differing_extents_in_dimensi __pyx_mstate_global->__pyx_kp_u_got_differing_extents_in_dimensi
-#define __pyx_n_s_id __pyx_mstate_global->__pyx_n_s_id
-#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import
-#define __pyx_n_s_index __pyx_mstate_global->__pyx_n_s_index
-#define __pyx_n_s_initializing __pyx_mstate_global->__pyx_n_s_initializing
-#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine
-#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled
-#define __pyx_n_s_itemsize __pyx_mstate_global->__pyx_n_s_itemsize
-#define __pyx_kp_s_itemsize_0_for_cython_array __pyx_mstate_global->__pyx_kp_s_itemsize_0_for_cython_array
-#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main
-#define __pyx_n_s_maximum_path_c __pyx_mstate_global->__pyx_n_s_maximum_path_c
-#define __pyx_n_s_memview __pyx_mstate_global->__pyx_n_s_memview
-#define __pyx_n_s_mode __pyx_mstate_global->__pyx_n_s_mode
-#define __pyx_n_s_monotonic_align_core __pyx_mstate_global->__pyx_n_s_monotonic_align_core
-#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name
-#define __pyx_n_s_name_2 __pyx_mstate_global->__pyx_n_s_name_2
-#define __pyx_n_s_ndim __pyx_mstate_global->__pyx_n_s_ndim
-#define __pyx_n_s_new __pyx_mstate_global->__pyx_n_s_new
-#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non
-#define __pyx_n_s_obj __pyx_mstate_global->__pyx_n_s_obj
-#define __pyx_n_s_pack __pyx_mstate_global->__pyx_n_s_pack
-#define __pyx_n_s_paths __pyx_mstate_global->__pyx_n_s_paths
-#define __pyx_n_s_pickle __pyx_mstate_global->__pyx_n_s_pickle
-#define __pyx_n_s_pyx_PickleError __pyx_mstate_global->__pyx_n_s_pyx_PickleError
-#define __pyx_n_s_pyx_checksum __pyx_mstate_global->__pyx_n_s_pyx_checksum
-#define __pyx_n_s_pyx_result __pyx_mstate_global->__pyx_n_s_pyx_result
-#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state
-#define __pyx_n_s_pyx_type __pyx_mstate_global->__pyx_n_s_pyx_type
-#define __pyx_n_s_pyx_unpickle_Enum __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Enum
-#define __pyx_n_s_pyx_vtable __pyx_mstate_global->__pyx_n_s_pyx_vtable
-#define __pyx_n_s_range __pyx_mstate_global->__pyx_n_s_range
-#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce
-#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython
-#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex
-#define __pyx_n_s_register __pyx_mstate_global->__pyx_n_s_register
-#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate
-#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython
-#define __pyx_n_s_shape __pyx_mstate_global->__pyx_n_s_shape
-#define __pyx_n_s_size __pyx_mstate_global->__pyx_n_s_size
-#define __pyx_n_s_spec __pyx_mstate_global->__pyx_n_s_spec
-#define __pyx_n_s_start __pyx_mstate_global->__pyx_n_s_start
-#define __pyx_n_s_step __pyx_mstate_global->__pyx_n_s_step
-#define __pyx_n_s_stop __pyx_mstate_global->__pyx_n_s_stop
-#define __pyx_kp_s_strided_and_direct __pyx_mstate_global->__pyx_kp_s_strided_and_direct
-#define __pyx_kp_s_strided_and_direct_or_indirect __pyx_mstate_global->__pyx_kp_s_strided_and_direct_or_indirect
-#define __pyx_kp_s_strided_and_indirect __pyx_mstate_global->__pyx_kp_s_strided_and_indirect
-#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource
-#define __pyx_n_s_struct __pyx_mstate_global->__pyx_n_s_struct
-#define __pyx_n_s_sys __pyx_mstate_global->__pyx_n_s_sys
-#define __pyx_n_s_t_xs __pyx_mstate_global->__pyx_n_s_t_xs
-#define __pyx_n_s_t_ys __pyx_mstate_global->__pyx_n_s_t_ys
-#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test
-#define __pyx_kp_s_unable_to_allocate_array_data __pyx_mstate_global->__pyx_kp_s_unable_to_allocate_array_data
-#define __pyx_kp_s_unable_to_allocate_shape_and_str __pyx_mstate_global->__pyx_kp_s_unable_to_allocate_shape_and_str
-#define __pyx_n_s_unpack __pyx_mstate_global->__pyx_n_s_unpack
-#define __pyx_n_s_update __pyx_mstate_global->__pyx_n_s_update
-#define __pyx_n_s_values __pyx_mstate_global->__pyx_n_s_values
-#define __pyx_n_s_version_info __pyx_mstate_global->__pyx_n_s_version_info
-#define __pyx_int_0 __pyx_mstate_global->__pyx_int_0
-#define __pyx_int_1 __pyx_mstate_global->__pyx_int_1
-#define __pyx_int_3 __pyx_mstate_global->__pyx_int_3
-#define __pyx_int_112105877 __pyx_mstate_global->__pyx_int_112105877
-#define __pyx_int_136983863 __pyx_mstate_global->__pyx_int_136983863
-#define __pyx_int_184977713 __pyx_mstate_global->__pyx_int_184977713
-#define __pyx_int_neg_1 __pyx_mstate_global->__pyx_int_neg_1
-#define __pyx_k__9 __pyx_mstate_global->__pyx_k__9
-#define __pyx_slice__5 __pyx_mstate_global->__pyx_slice__5
-#define __pyx_tuple__4 __pyx_mstate_global->__pyx_tuple__4
-#define __pyx_tuple__8 __pyx_mstate_global->__pyx_tuple__8
-#define __pyx_tuple__10 __pyx_mstate_global->__pyx_tuple__10
-#define __pyx_tuple__11 __pyx_mstate_global->__pyx_tuple__11
-#define __pyx_tuple__12 __pyx_mstate_global->__pyx_tuple__12
-#define __pyx_tuple__13 __pyx_mstate_global->__pyx_tuple__13
-#define __pyx_tuple__14 __pyx_mstate_global->__pyx_tuple__14
-#define __pyx_tuple__15 __pyx_mstate_global->__pyx_tuple__15
-#define __pyx_tuple__16 __pyx_mstate_global->__pyx_tuple__16
-#define __pyx_tuple__17 __pyx_mstate_global->__pyx_tuple__17
-#define __pyx_tuple__18 __pyx_mstate_global->__pyx_tuple__18
-#define __pyx_tuple__19 __pyx_mstate_global->__pyx_tuple__19
-#define __pyx_tuple__21 __pyx_mstate_global->__pyx_tuple__21
-#define __pyx_codeobj__20 __pyx_mstate_global->__pyx_codeobj__20
-#define __pyx_codeobj__22 __pyx_mstate_global->__pyx_codeobj__22
-/* #### Code section: module_code ### */
-
-/* "View.MemoryView":131
- * cdef bint dtype_is_object
- *
- * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<<
- * mode="c", bint allocate_buffer=True):
- *
- */
-
-/* Python wrapper */
-static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
- PyObject *__pyx_v_shape = 0;
- Py_ssize_t __pyx_v_itemsize;
- PyObject *__pyx_v_format = 0;
- PyObject *__pyx_v_mode = 0;
- int __pyx_v_allocate_buffer;
- CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- int __pyx_r;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
- {
- PyObject **__pyx_pyargnames[] = {&__pyx_n_s_shape,&__pyx_n_s_itemsize,&__pyx_n_s_format,&__pyx_n_s_mode,&__pyx_n_s_allocate_buffer,0};
- PyObject* values[5] = {0,0,0,0,0};
- values[3] = ((PyObject *)__pyx_n_s_c);
- if (__pyx_kwds) {
- Py_ssize_t kw_args;
- switch (__pyx_nargs) {
- case 5: values[4] = __Pyx_Arg_VARARGS(__pyx_args, 4);
- CYTHON_FALLTHROUGH;
- case 4: values[3] = __Pyx_Arg_VARARGS(__pyx_args, 3);
- CYTHON_FALLTHROUGH;
- case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2);
- CYTHON_FALLTHROUGH;
- case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1);
- CYTHON_FALLTHROUGH;
- case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
- CYTHON_FALLTHROUGH;
- case 0: break;
- default: goto __pyx_L5_argtuple_error;
- }
- kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds);
- switch (__pyx_nargs) {
- case 0:
- if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_shape)) != 0)) kw_args--;
- else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error)
- else goto __pyx_L5_argtuple_error;
- CYTHON_FALLTHROUGH;
- case 1:
- if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_itemsize)) != 0)) kw_args--;
- else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error)
- else {
- __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 1); __PYX_ERR(1, 131, __pyx_L3_error)
- }
- CYTHON_FALLTHROUGH;
- case 2:
- if (likely((values[2] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_format)) != 0)) kw_args--;
- else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error)
- else {
- __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 2); __PYX_ERR(1, 131, __pyx_L3_error)
- }
- CYTHON_FALLTHROUGH;
- case 3:
- if (kw_args > 0) {
- PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_mode);
- if (value) { values[3] = value; kw_args--; }
- else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error)
- }
- CYTHON_FALLTHROUGH;
- case 4:
- if (kw_args > 0) {
- PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_allocate_buffer);
- if (value) { values[4] = value; kw_args--; }
- else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error)
- }
- }
- if (unlikely(kw_args > 0)) {
- const Py_ssize_t kwd_pos_args = __pyx_nargs;
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(1, 131, __pyx_L3_error)
- }
- } else {
- switch (__pyx_nargs) {
- case 5: values[4] = __Pyx_Arg_VARARGS(__pyx_args, 4);
- CYTHON_FALLTHROUGH;
- case 4: values[3] = __Pyx_Arg_VARARGS(__pyx_args, 3);
- CYTHON_FALLTHROUGH;
- case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2);
- values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1);
- values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
- break;
- default: goto __pyx_L5_argtuple_error;
- }
- }
- __pyx_v_shape = ((PyObject*)values[0]);
- __pyx_v_itemsize = __Pyx_PyIndex_AsSsize_t(values[1]); if (unlikely((__pyx_v_itemsize == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error)
- __pyx_v_format = values[2];
- __pyx_v_mode = values[3];
- if (values[4]) {
- __pyx_v_allocate_buffer = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_allocate_buffer == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 132, __pyx_L3_error)
- } else {
-
- /* "View.MemoryView":132
- *
- * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None,
- * mode="c", bint allocate_buffer=True): # <<<<<<<<<<<<<<
- *
- * cdef int idx
- */
- __pyx_v_allocate_buffer = ((int)1);
- }
- }
- goto __pyx_L4_argument_unpacking_done;
- __pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, __pyx_nargs); __PYX_ERR(1, 131, __pyx_L3_error)
- __pyx_L3_error:;
- __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __Pyx_RefNannyFinishContext();
- return -1;
- __pyx_L4_argument_unpacking_done:;
- if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_shape), (&PyTuple_Type), 1, "shape", 1))) __PYX_ERR(1, 131, __pyx_L1_error)
- if (unlikely(((PyObject *)__pyx_v_format) == Py_None)) {
- PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "format"); __PYX_ERR(1, 131, __pyx_L1_error)
- }
- __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v_shape, __pyx_v_itemsize, __pyx_v_format, __pyx_v_mode, __pyx_v_allocate_buffer);
-
- /* "View.MemoryView":131
- * cdef bint dtype_is_object
- *
- * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<<
- * mode="c", bint allocate_buffer=True):
- *
- */
-
- /* function exit code */
- goto __pyx_L0;
- __pyx_L1_error:;
- __pyx_r = -1;
- __pyx_L0:;
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer) {
- int __pyx_v_idx;
- Py_ssize_t __pyx_v_dim;
- char __pyx_v_order;
- int __pyx_r;
- __Pyx_RefNannyDeclarations
- Py_ssize_t __pyx_t_1;
- int __pyx_t_2;
- int __pyx_t_3;
- PyObject *__pyx_t_4 = NULL;
- PyObject *__pyx_t_5 = NULL;
- PyObject *__pyx_t_6 = NULL;
- int __pyx_t_7;
- char *__pyx_t_8;
- Py_ssize_t __pyx_t_9;
- Py_UCS4 __pyx_t_10;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("__cinit__", 0);
- __Pyx_INCREF(__pyx_v_format);
-
- /* "View.MemoryView":137
- * cdef Py_ssize_t dim
- *
- * self.ndim = len(shape) # <<<<<<<<<<<<<<
- * self.itemsize = itemsize
- *
- */
- if (unlikely(__pyx_v_shape == Py_None)) {
- PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
- __PYX_ERR(1, 137, __pyx_L1_error)
- }
- __pyx_t_1 = PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 137, __pyx_L1_error)
- __pyx_v_self->ndim = ((int)__pyx_t_1);
-
- /* "View.MemoryView":138
- *
- * self.ndim = len(shape)
- * self.itemsize = itemsize # <<<<<<<<<<<<<<
- *
- * if not self.ndim:
- */
- __pyx_v_self->itemsize = __pyx_v_itemsize;
-
- /* "View.MemoryView":140
- * self.itemsize = itemsize
- *
- * if not self.ndim: # <<<<<<<<<<<<<<
- * raise ValueError, "Empty shape tuple for cython.array"
- *
- */
- __pyx_t_2 = (!(__pyx_v_self->ndim != 0));
- if (unlikely(__pyx_t_2)) {
-
- /* "View.MemoryView":141
- *
- * if not self.ndim:
- * raise ValueError, "Empty shape tuple for cython.array" # <<<<<<<<<<<<<<
- *
- * if itemsize <= 0:
- */
- __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Empty_shape_tuple_for_cython_arr, 0, 0);
- __PYX_ERR(1, 141, __pyx_L1_error)
-
- /* "View.MemoryView":140
- * self.itemsize = itemsize
- *
- * if not self.ndim: # <<<<<<<<<<<<<<
- * raise ValueError, "Empty shape tuple for cython.array"
- *
- */
- }
-
- /* "View.MemoryView":143
- * raise ValueError, "Empty shape tuple for cython.array"
- *
- * if itemsize <= 0: # <<<<<<<<<<<<<<
- * raise ValueError, "itemsize <= 0 for cython.array"
- *
- */
- __pyx_t_2 = (__pyx_v_itemsize <= 0);
- if (unlikely(__pyx_t_2)) {
-
- /* "View.MemoryView":144
- *
- * if itemsize <= 0:
- * raise ValueError, "itemsize <= 0 for cython.array" # <<<<<<<<<<<<<<
- *
- * if not isinstance(format, bytes):
- */
- __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_itemsize_0_for_cython_array, 0, 0);
- __PYX_ERR(1, 144, __pyx_L1_error)
-
- /* "View.MemoryView":143
- * raise ValueError, "Empty shape tuple for cython.array"
- *
- * if itemsize <= 0: # <<<<<<<<<<<<<<
- * raise ValueError, "itemsize <= 0 for cython.array"
- *
- */
- }
-
- /* "View.MemoryView":146
- * raise ValueError, "itemsize <= 0 for cython.array"
- *
- * if not isinstance(format, bytes): # <<<<<<<<<<<<<<
- * format = format.encode('ASCII')
- * self._format = format # keep a reference to the byte string
- */
- __pyx_t_2 = PyBytes_Check(__pyx_v_format);
- __pyx_t_3 = (!__pyx_t_2);
- if (__pyx_t_3) {
-
- /* "View.MemoryView":147
- *
- * if not isinstance(format, bytes):
- * format = format.encode('ASCII') # <<<<<<<<<<<<<<
- * self._format = format # keep a reference to the byte string
- * self.format = self._format
- */
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 147, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = NULL;
- __pyx_t_7 = 0;
- if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
- __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
- if (likely(__pyx_t_6)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
- __Pyx_INCREF(__pyx_t_6);
- __Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_5, function);
- __pyx_t_7 = 1;
- }
- }
- {
- PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_n_s_ASCII};
- __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7);
- __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
- if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 147, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_4);
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- }
- __Pyx_DECREF_SET(__pyx_v_format, __pyx_t_4);
- __pyx_t_4 = 0;
-
- /* "View.MemoryView":146
- * raise ValueError, "itemsize <= 0 for cython.array"
- *
- * if not isinstance(format, bytes): # <<<<<<<<<<<<<<
- * format = format.encode('ASCII')
- * self._format = format # keep a reference to the byte string
- */
- }
-
- /* "View.MemoryView":148
- * if not isinstance(format, bytes):
- * format = format.encode('ASCII')
- * self._format = format # keep a reference to the byte string # <<<<<<<<<<<<<<
- * self.format = self._format
- *
- */
- if (!(likely(PyBytes_CheckExact(__pyx_v_format))||((__pyx_v_format) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_v_format))) __PYX_ERR(1, 148, __pyx_L1_error)
- __pyx_t_4 = __pyx_v_format;
- __Pyx_INCREF(__pyx_t_4);
- __Pyx_GIVEREF(__pyx_t_4);
- __Pyx_GOTREF(__pyx_v_self->_format);
- __Pyx_DECREF(__pyx_v_self->_format);
- __pyx_v_self->_format = ((PyObject*)__pyx_t_4);
- __pyx_t_4 = 0;
-
- /* "View.MemoryView":149
- * format = format.encode('ASCII')
- * self._format = format # keep a reference to the byte string
- * self.format = self._format # <<<<<<<<<<<<<<
- *
- *
- */
- if (unlikely(__pyx_v_self->_format == Py_None)) {
- PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
- __PYX_ERR(1, 149, __pyx_L1_error)
- }
- __pyx_t_8 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_8) && PyErr_Occurred())) __PYX_ERR(1, 149, __pyx_L1_error)
- __pyx_v_self->format = __pyx_t_8;
-
- /* "View.MemoryView":152
- *
- *
- * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) # <<<<<<<<<<<<<<
- * self._strides = self._shape + self.ndim
- *
- */
- __pyx_v_self->_shape = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * __pyx_v_self->ndim) * 2)));
-
- /* "View.MemoryView":153
- *
- * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2)
- * self._strides = self._shape + self.ndim # <<<<<<<<<<<<<<
- *
- * if not self._shape:
- */
- __pyx_v_self->_strides = (__pyx_v_self->_shape + __pyx_v_self->ndim);
-
- /* "View.MemoryView":155
- * self._strides = self._shape + self.ndim
- *
- * if not self._shape: # <<<<<<<<<<<<<<
- * raise MemoryError, "unable to allocate shape and strides."
- *
- */
- __pyx_t_3 = (!(__pyx_v_self->_shape != 0));
- if (unlikely(__pyx_t_3)) {
-
- /* "View.MemoryView":156
- *
- * if not self._shape:
- * raise MemoryError, "unable to allocate shape and strides." # <<<<<<<<<<<<<<
- *
- *
- */
- __Pyx_Raise(__pyx_builtin_MemoryError, __pyx_kp_s_unable_to_allocate_shape_and_str, 0, 0);
- __PYX_ERR(1, 156, __pyx_L1_error)
-
- /* "View.MemoryView":155
- * self._strides = self._shape + self.ndim
- *
- * if not self._shape: # <<<<<<<<<<<<<<
- * raise MemoryError, "unable to allocate shape and strides."
- *
- */
- }
-
- /* "View.MemoryView":159
- *
- *
- * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<<
- * if dim <= 0:
- * raise ValueError, f"Invalid shape in axis {idx}: {dim}."
- */
- __pyx_t_7 = 0;
- __pyx_t_4 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_4); __pyx_t_1 = 0;
- for (;;) {
- if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
- #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
- __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(1, 159, __pyx_L1_error)
- #else
- __pyx_t_5 = PySequence_ITEM(__pyx_t_4, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 159, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_5);
- #endif
- __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 159, __pyx_L1_error)
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_v_dim = __pyx_t_9;
- __pyx_v_idx = __pyx_t_7;
- __pyx_t_7 = (__pyx_t_7 + 1);
-
- /* "View.MemoryView":160
- *
- * for idx, dim in enumerate(shape):
- * if dim <= 0: # <<<<<<<<<<<<<<
- * raise ValueError, f"Invalid shape in axis {idx}: {dim}."
- * self._shape[idx] = dim
- */
- __pyx_t_3 = (__pyx_v_dim <= 0);
- if (unlikely(__pyx_t_3)) {
-
- /* "View.MemoryView":161
- * for idx, dim in enumerate(shape):
- * if dim <= 0:
- * raise ValueError, f"Invalid shape in axis {idx}: {dim}." # <<<<<<<<<<<<<<
- * self._shape[idx] = dim
- *
- */
- __pyx_t_5 = PyTuple_New(5); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 161, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_5);
- __pyx_t_9 = 0;
- __pyx_t_10 = 127;
- __Pyx_INCREF(__pyx_kp_u_Invalid_shape_in_axis);
- __pyx_t_9 += 22;
- __Pyx_GIVEREF(__pyx_kp_u_Invalid_shape_in_axis);
- PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_kp_u_Invalid_shape_in_axis);
- __pyx_t_6 = __Pyx_PyUnicode_From_int(__pyx_v_idx, 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 161, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_6);
- __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6);
- __Pyx_GIVEREF(__pyx_t_6);
- PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_6);
- __pyx_t_6 = 0;
- __Pyx_INCREF(__pyx_kp_u_);
- __pyx_t_9 += 2;
- __Pyx_GIVEREF(__pyx_kp_u_);
- PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_kp_u_);
- __pyx_t_6 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 161, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_6);
- __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6);
- __Pyx_GIVEREF(__pyx_t_6);
- PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_6);
- __pyx_t_6 = 0;
- __Pyx_INCREF(__pyx_kp_u__2);
- __pyx_t_9 += 1;
- __Pyx_GIVEREF(__pyx_kp_u__2);
- PyTuple_SET_ITEM(__pyx_t_5, 4, __pyx_kp_u__2);
- __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_5, 5, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 161, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_6);
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __Pyx_Raise(__pyx_builtin_ValueError, __pyx_t_6, 0, 0);
- __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __PYX_ERR(1, 161, __pyx_L1_error)
-
- /* "View.MemoryView":160
- *
- * for idx, dim in enumerate(shape):
- * if dim <= 0: # <<<<<<<<<<<<<<
- * raise ValueError, f"Invalid shape in axis {idx}: {dim}."
- * self._shape[idx] = dim
- */
- }
-
- /* "View.MemoryView":162
- * if dim <= 0:
- * raise ValueError, f"Invalid shape in axis {idx}: {dim}."
- * self._shape[idx] = dim # <<<<<<<<<<<<<<
- *
- * cdef char order
- */
- (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim;
-
- /* "View.MemoryView":159
- *
- *
- * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<<
- * if dim <= 0:
- * raise ValueError, f"Invalid shape in axis {idx}: {dim}."
- */
- }
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-
- /* "View.MemoryView":165
- *
- * cdef char order
- * if mode == 'c': # <<<<<<<<<<<<<<
- * order = b'C'
- * self.mode = u'c'
- */
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_c, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 165, __pyx_L1_error)
- if (__pyx_t_3) {
-
- /* "View.MemoryView":166
- * cdef char order
- * if mode == 'c':
- * order = b'C' # <<<<<<<<<<<<<<
- * self.mode = u'c'
- * elif mode == 'fortran':
- */
- __pyx_v_order = 'C';
-
- /* "View.MemoryView":167
- * if mode == 'c':
- * order = b'C'
- * self.mode = u'c' # <<<<<<<<<<<<<<
- * elif mode == 'fortran':
- * order = b'F'
- */
- __Pyx_INCREF(__pyx_n_u_c);
- __Pyx_GIVEREF(__pyx_n_u_c);
- __Pyx_GOTREF(__pyx_v_self->mode);
- __Pyx_DECREF(__pyx_v_self->mode);
- __pyx_v_self->mode = __pyx_n_u_c;
-
- /* "View.MemoryView":165
- *
- * cdef char order
- * if mode == 'c': # <<<<<<<<<<<<<<
- * order = b'C'
- * self.mode = u'c'
- */
- goto __pyx_L11;
- }
-
- /* "View.MemoryView":168
- * order = b'C'
- * self.mode = u'c'
- * elif mode == 'fortran': # <<<<<<<<<<<<<<
- * order = b'F'
- * self.mode = u'fortran'
- */
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_fortran, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 168, __pyx_L1_error)
- if (likely(__pyx_t_3)) {
-
- /* "View.MemoryView":169
- * self.mode = u'c'
- * elif mode == 'fortran':
- * order = b'F' # <<<<<<<<<<<<<<
- * self.mode = u'fortran'
- * else:
- */
- __pyx_v_order = 'F';
-
- /* "View.MemoryView":170
- * elif mode == 'fortran':
- * order = b'F'
- * self.mode = u'fortran' # <<<<<<<<<<<<<<
- * else:
- * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}"
- */
- __Pyx_INCREF(__pyx_n_u_fortran);
- __Pyx_GIVEREF(__pyx_n_u_fortran);
- __Pyx_GOTREF(__pyx_v_self->mode);
- __Pyx_DECREF(__pyx_v_self->mode);
- __pyx_v_self->mode = __pyx_n_u_fortran;
-
- /* "View.MemoryView":168
- * order = b'C'
- * self.mode = u'c'
- * elif mode == 'fortran': # <<<<<<<<<<<<<<
- * order = b'F'
- * self.mode = u'fortran'
- */
- goto __pyx_L11;
- }
-
- /* "View.MemoryView":172
- * self.mode = u'fortran'
- * else:
- * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" # <<<<<<<<<<<<<<
- *
- * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order)
- */
- /*else*/ {
- __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_v_mode, __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 172, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_4);
- __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Invalid_mode_expected_c_or_fortr, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 172, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_6);
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __Pyx_Raise(__pyx_builtin_ValueError, __pyx_t_6, 0, 0);
- __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __PYX_ERR(1, 172, __pyx_L1_error)
- }
- __pyx_L11:;
-
- /* "View.MemoryView":174
- * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}"
- *
- * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) # <<<<<<<<<<<<<<
- *
- * self.free_data = allocate_buffer
- */
- __pyx_v_self->len = __pyx_fill_contig_strides_array(__pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_itemsize, __pyx_v_self->ndim, __pyx_v_order);
-
- /* "View.MemoryView":176
- * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order)
- *
- * self.free_data = allocate_buffer # <<<<<<<<<<<<<<
- * self.dtype_is_object = format == b'O'
- *
- */
- __pyx_v_self->free_data = __pyx_v_allocate_buffer;
-
- /* "View.MemoryView":177
- *
- * self.free_data = allocate_buffer
- * self.dtype_is_object = format == b'O' # <<<<<<<<<<<<<<
- *
- * if allocate_buffer:
- */
- __pyx_t_6 = PyObject_RichCompare(__pyx_v_format, __pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 177, __pyx_L1_error)
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 177, __pyx_L1_error)
- __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_v_self->dtype_is_object = __pyx_t_3;
-
- /* "View.MemoryView":179
- * self.dtype_is_object = format == b'O'
- *
- * if allocate_buffer: # <<<<<<<<<<<<<<
- * _allocate_buffer(self)
- *
- */
- if (__pyx_v_allocate_buffer) {
-
- /* "View.MemoryView":180
- *
- * if allocate_buffer:
- * _allocate_buffer(self) # <<<<<<<<<<<<<<
- *
- * @cname('getbuffer')
- */
- __pyx_t_7 = __pyx_array_allocate_buffer(__pyx_v_self); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(1, 180, __pyx_L1_error)
-
- /* "View.MemoryView":179
- * self.dtype_is_object = format == b'O'
- *
- * if allocate_buffer: # <<<<<<<<<<<<<<
- * _allocate_buffer(self)
- *
- */
- }
-
- /* "View.MemoryView":131
- * cdef bint dtype_is_object
- *
- * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<<
- * mode="c", bint allocate_buffer=True):
- *
- */
-
- /* function exit code */
- __pyx_r = 0;
- goto __pyx_L0;
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_4);
- __Pyx_XDECREF(__pyx_t_5);
- __Pyx_XDECREF(__pyx_t_6);
- __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = -1;
- __pyx_L0:;
- __Pyx_XDECREF(__pyx_v_format);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":182
- * _allocate_buffer(self)
- *
- * @cname('getbuffer') # <<<<<<<<<<<<<<
- * def __getbuffer__(self, Py_buffer *info, int flags):
- * cdef int bufmode = -1
- */
-
-/* Python wrapper */
-CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
-CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- int __pyx_r;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
- __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(((struct __pyx_array_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
- int __pyx_v_bufmode;
- int __pyx_r;
- __Pyx_RefNannyDeclarations
- int __pyx_t_1;
- char *__pyx_t_2;
- Py_ssize_t __pyx_t_3;
- int __pyx_t_4;
- Py_ssize_t *__pyx_t_5;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- if (unlikely(__pyx_v_info == NULL)) {
- PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete");
- return -1;
- }
- __Pyx_RefNannySetupContext("__getbuffer__", 0);
- __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None);
- __Pyx_GIVEREF(__pyx_v_info->obj);
-
- /* "View.MemoryView":184
- * @cname('getbuffer')
- * def __getbuffer__(self, Py_buffer *info, int flags):
- * cdef int bufmode = -1 # <<<<<<<<<<<<<<
- * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS):
- * if self.mode == u"c":
- */
- __pyx_v_bufmode = -1;
-
- /* "View.MemoryView":185
- * def __getbuffer__(self, Py_buffer *info, int flags):
- * cdef int bufmode = -1
- * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): # <<<<<<<<<<<<<<
- * if self.mode == u"c":
- * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- */
- __pyx_t_1 = ((__pyx_v_flags & ((PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS) | PyBUF_ANY_CONTIGUOUS)) != 0);
- if (__pyx_t_1) {
-
- /* "View.MemoryView":186
- * cdef int bufmode = -1
- * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS):
- * if self.mode == u"c": # <<<<<<<<<<<<<<
- * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- * elif self.mode == u"fortran":
- */
- __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_c, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 186, __pyx_L1_error)
- if (__pyx_t_1) {
-
- /* "View.MemoryView":187
- * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS):
- * if self.mode == u"c":
- * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<<
- * elif self.mode == u"fortran":
- * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- */
- __pyx_v_bufmode = (PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS);
-
- /* "View.MemoryView":186
- * cdef int bufmode = -1
- * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS):
- * if self.mode == u"c": # <<<<<<<<<<<<<<
- * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- * elif self.mode == u"fortran":
- */
- goto __pyx_L4;
- }
-
- /* "View.MemoryView":188
- * if self.mode == u"c":
- * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- * elif self.mode == u"fortran": # <<<<<<<<<<<<<<
- * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- * if not (flags & bufmode):
- */
- __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_fortran, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 188, __pyx_L1_error)
- if (__pyx_t_1) {
-
- /* "View.MemoryView":189
- * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- * elif self.mode == u"fortran":
- * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<<
- * if not (flags & bufmode):
- * raise ValueError, "Can only create a buffer that is contiguous in memory."
- */
- __pyx_v_bufmode = (PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS);
-
- /* "View.MemoryView":188
- * if self.mode == u"c":
- * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- * elif self.mode == u"fortran": # <<<<<<<<<<<<<<
- * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- * if not (flags & bufmode):
- */
- }
- __pyx_L4:;
-
- /* "View.MemoryView":190
- * elif self.mode == u"fortran":
- * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- * if not (flags & bufmode): # <<<<<<<<<<<<<<
- * raise ValueError, "Can only create a buffer that is contiguous in memory."
- * info.buf = self.data
- */
- __pyx_t_1 = (!((__pyx_v_flags & __pyx_v_bufmode) != 0));
- if (unlikely(__pyx_t_1)) {
-
- /* "View.MemoryView":191
- * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- * if not (flags & bufmode):
- * raise ValueError, "Can only create a buffer that is contiguous in memory." # <<<<<<<<<<<<<<
- * info.buf = self.data
- * info.len = self.len
- */
- __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Can_only_create_a_buffer_that_is, 0, 0);
- __PYX_ERR(1, 191, __pyx_L1_error)
-
- /* "View.MemoryView":190
- * elif self.mode == u"fortran":
- * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- * if not (flags & bufmode): # <<<<<<<<<<<<<<
- * raise ValueError, "Can only create a buffer that is contiguous in memory."
- * info.buf = self.data
- */
- }
-
- /* "View.MemoryView":185
- * def __getbuffer__(self, Py_buffer *info, int flags):
- * cdef int bufmode = -1
- * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): # <<<<<<<<<<<<<<
- * if self.mode == u"c":
- * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
- */
- }
-
- /* "View.MemoryView":192
- * if not (flags & bufmode):
- * raise ValueError, "Can only create a buffer that is contiguous in memory."
- * info.buf = self.data # <<<<<<<<<<<<<<
- * info.len = self.len
- *
- */
- __pyx_t_2 = __pyx_v_self->data;
- __pyx_v_info->buf = __pyx_t_2;
-
- /* "View.MemoryView":193
- * raise ValueError, "Can only create a buffer that is contiguous in memory."
- * info.buf = self.data
- * info.len = self.len # <<<<<<<<<<<<<<
- *
- * if flags & PyBUF_STRIDES:
- */
- __pyx_t_3 = __pyx_v_self->len;
- __pyx_v_info->len = __pyx_t_3;
-
- /* "View.MemoryView":195
- * info.len = self.len
- *
- * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<<
- * info.ndim = self.ndim
- * info.shape = self._shape
- */
- __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0);
- if (__pyx_t_1) {
-
- /* "View.MemoryView":196
- *
- * if flags & PyBUF_STRIDES:
- * info.ndim = self.ndim # <<<<<<<<<<<<<<
- * info.shape = self._shape
- * info.strides = self._strides
- */
- __pyx_t_4 = __pyx_v_self->ndim;
- __pyx_v_info->ndim = __pyx_t_4;
-
- /* "View.MemoryView":197
- * if flags & PyBUF_STRIDES:
- * info.ndim = self.ndim
- * info.shape = self._shape # <<<<<<<<<<<<<<
- * info.strides = self._strides
- * else:
- */
- __pyx_t_5 = __pyx_v_self->_shape;
- __pyx_v_info->shape = __pyx_t_5;
-
- /* "View.MemoryView":198
- * info.ndim = self.ndim
- * info.shape = self._shape
- * info.strides = self._strides # <<<<<<<<<<<<<<
- * else:
- * info.ndim = 1
- */
- __pyx_t_5 = __pyx_v_self->_strides;
- __pyx_v_info->strides = __pyx_t_5;
-
- /* "View.MemoryView":195
- * info.len = self.len
- *
- * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<<
- * info.ndim = self.ndim
- * info.shape = self._shape
- */
- goto __pyx_L6;
- }
-
- /* "View.MemoryView":200
- * info.strides = self._strides
- * else:
- * info.ndim = 1 # <<<<<<<<<<<<<<
- * info.shape = &self.len if flags & PyBUF_ND else NULL
- * info.strides = NULL
- */
- /*else*/ {
- __pyx_v_info->ndim = 1;
-
- /* "View.MemoryView":201
- * else:
- * info.ndim = 1
- * info.shape = &self.len if flags & PyBUF_ND else NULL # <<<<<<<<<<<<<<
- * info.strides = NULL
- *
- */
- if (((__pyx_v_flags & PyBUF_ND) != 0)) {
- __pyx_t_5 = (&__pyx_v_self->len);
- } else {
- __pyx_t_5 = NULL;
- }
- __pyx_v_info->shape = __pyx_t_5;
-
- /* "View.MemoryView":202
- * info.ndim = 1
- * info.shape = &self.len if flags & PyBUF_ND else NULL
- * info.strides = NULL # <<<<<<<<<<<<<<
- *
- * info.suboffsets = NULL
- */
- __pyx_v_info->strides = NULL;
- }
- __pyx_L6:;
-
- /* "View.MemoryView":204
- * info.strides = NULL
- *
- * info.suboffsets = NULL # <<<<<<<<<<<<<<
- * info.itemsize = self.itemsize
- * info.readonly = 0
- */
- __pyx_v_info->suboffsets = NULL;
-
- /* "View.MemoryView":205
- *
- * info.suboffsets = NULL
- * info.itemsize = self.itemsize # <<<<<<<<<<<<<<
- * info.readonly = 0
- * info.format = self.format if flags & PyBUF_FORMAT else NULL
- */
- __pyx_t_3 = __pyx_v_self->itemsize;
- __pyx_v_info->itemsize = __pyx_t_3;
-
- /* "View.MemoryView":206
- * info.suboffsets = NULL
- * info.itemsize = self.itemsize
- * info.readonly = 0 # <<<<<<<<<<<<<<
- * info.format = self.format if flags & PyBUF_FORMAT else NULL
- * info.obj = self
- */
- __pyx_v_info->readonly = 0;
-
- /* "View.MemoryView":207
- * info.itemsize = self.itemsize
- * info.readonly = 0
- * info.format = self.format if flags & PyBUF_FORMAT else NULL # <<<<<<<<<<<<<<
- * info.obj = self
- *
- */
- if (((__pyx_v_flags & PyBUF_FORMAT) != 0)) {
- __pyx_t_2 = __pyx_v_self->format;
- } else {
- __pyx_t_2 = NULL;
- }
- __pyx_v_info->format = __pyx_t_2;
-
- /* "View.MemoryView":208
- * info.readonly = 0
- * info.format = self.format if flags & PyBUF_FORMAT else NULL
- * info.obj = self # <<<<<<<<<<<<<<
- *
- * def __dealloc__(array self):
- */
- __Pyx_INCREF((PyObject *)__pyx_v_self);
- __Pyx_GIVEREF((PyObject *)__pyx_v_self);
- __Pyx_GOTREF(__pyx_v_info->obj);
- __Pyx_DECREF(__pyx_v_info->obj);
- __pyx_v_info->obj = ((PyObject *)__pyx_v_self);
-
- /* "View.MemoryView":182
- * _allocate_buffer(self)
- *
- * @cname('getbuffer') # <<<<<<<<<<<<<<
- * def __getbuffer__(self, Py_buffer *info, int flags):
- * cdef int bufmode = -1
- */
-
- /* function exit code */
- __pyx_r = 0;
- goto __pyx_L0;
- __pyx_L1_error:;
- __Pyx_AddTraceback("View.MemoryView.array.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = -1;
- if (__pyx_v_info->obj != NULL) {
- __Pyx_GOTREF(__pyx_v_info->obj);
- __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
- }
- goto __pyx_L2;
- __pyx_L0:;
- if (__pyx_v_info->obj == Py_None) {
- __Pyx_GOTREF(__pyx_v_info->obj);
- __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
- }
- __pyx_L2:;
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":210
- * info.obj = self
- *
- * def __dealloc__(array self): # <<<<<<<<<<<<<<
- * if self.callback_free_data != NULL:
- * self.callback_free_data(self.data)
- */
-
-/* Python wrapper */
-static void __pyx_array___dealloc__(PyObject *__pyx_v_self); /*proto*/
-static void __pyx_array___dealloc__(PyObject *__pyx_v_self) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
- __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(((struct __pyx_array_obj *)__pyx_v_self));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
-}
-
-static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self) {
- __Pyx_RefNannyDeclarations
- int __pyx_t_1;
- int __pyx_t_2;
- __Pyx_RefNannySetupContext("__dealloc__", 0);
-
- /* "View.MemoryView":211
- *
- * def __dealloc__(array self):
- * if self.callback_free_data != NULL: # <<<<<<<<<<<<<<
- * self.callback_free_data(self.data)
- * elif self.free_data and self.data is not NULL:
- */
- __pyx_t_1 = (__pyx_v_self->callback_free_data != NULL);
- if (__pyx_t_1) {
-
- /* "View.MemoryView":212
- * def __dealloc__(array self):
- * if self.callback_free_data != NULL:
- * self.callback_free_data(self.data) # <<<<<<<<<<<<<<
- * elif self.free_data and self.data is not NULL:
- * if self.dtype_is_object:
- */
- __pyx_v_self->callback_free_data(__pyx_v_self->data);
-
- /* "View.MemoryView":211
- *
- * def __dealloc__(array self):
- * if self.callback_free_data != NULL: # <<<<<<<<<<<<<<
- * self.callback_free_data(self.data)
- * elif self.free_data and self.data is not NULL:
- */
- goto __pyx_L3;
- }
-
- /* "View.MemoryView":213
- * if self.callback_free_data != NULL:
- * self.callback_free_data(self.data)
- * elif self.free_data and self.data is not NULL: # <<<<<<<<<<<<<<
- * if self.dtype_is_object:
- * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False)
- */
- if (__pyx_v_self->free_data) {
- } else {
- __pyx_t_1 = __pyx_v_self->free_data;
- goto __pyx_L4_bool_binop_done;
- }
- __pyx_t_2 = (__pyx_v_self->data != NULL);
- __pyx_t_1 = __pyx_t_2;
- __pyx_L4_bool_binop_done:;
- if (__pyx_t_1) {
-
- /* "View.MemoryView":214
- * self.callback_free_data(self.data)
- * elif self.free_data and self.data is not NULL:
- * if self.dtype_is_object: # <<<<<<<<<<<<<<
- * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False)
- * free(self.data)
- */
- if (__pyx_v_self->dtype_is_object) {
-
- /* "View.MemoryView":215
- * elif self.free_data and self.data is not NULL:
- * if self.dtype_is_object:
- * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) # <<<<<<<<<<<<<<
- * free(self.data)
- * PyObject_Free(self._shape)
- */
- __pyx_memoryview_refcount_objects_in_slice(__pyx_v_self->data, __pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_self->ndim, 0);
-
- /* "View.MemoryView":214
- * self.callback_free_data(self.data)
- * elif self.free_data and self.data is not NULL:
- * if self.dtype_is_object: # <<<<<<<<<<<<<<
- * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False)
- * free(self.data)
- */
- }
-
- /* "View.MemoryView":216
- * if self.dtype_is_object:
- * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False)
- * free(self.data) # <<<<<<<<<<<<<<
- * PyObject_Free(self._shape)
- *
- */
- free(__pyx_v_self->data);
-
- /* "View.MemoryView":213
- * if self.callback_free_data != NULL:
- * self.callback_free_data(self.data)
- * elif self.free_data and self.data is not NULL: # <<<<<<<<<<<<<<
- * if self.dtype_is_object:
- * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False)
- */
- }
- __pyx_L3:;
-
- /* "View.MemoryView":217
- * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False)
- * free(self.data)
- * PyObject_Free(self._shape) # <<<<<<<<<<<<<<
- *
- * @property
- */
- PyObject_Free(__pyx_v_self->_shape);
-
- /* "View.MemoryView":210
- * info.obj = self
- *
- * def __dealloc__(array self): # <<<<<<<<<<<<<<
- * if self.callback_free_data != NULL:
- * self.callback_free_data(self.data)
- */
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
-}
-
-/* "View.MemoryView":219
- * PyObject_Free(self._shape)
- *
- * @property # <<<<<<<<<<<<<<
- * def memview(self):
- * return self.get_memview()
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- PyObject *__pyx_r = 0;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
- __pyx_r = __pyx_pf_15View_dot_MemoryView_5array_7memview___get__(((struct __pyx_array_obj *)__pyx_v_self));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self) {
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("__get__", 0);
-
- /* "View.MemoryView":221
- * @property
- * def memview(self):
- * return self.get_memview() # <<<<<<<<<<<<<<
- *
- * @cname('get_memview')
- */
- __Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = ((struct __pyx_vtabstruct_array *)__pyx_v_self->__pyx_vtab)->get_memview(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 221, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_r = __pyx_t_1;
- __pyx_t_1 = 0;
- goto __pyx_L0;
-
- /* "View.MemoryView":219
- * PyObject_Free(self._shape)
- *
- * @property # <<<<<<<<<<<<<<
- * def memview(self):
- * return self.get_memview()
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_1);
- __Pyx_AddTraceback("View.MemoryView.array.memview.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = NULL;
- __pyx_L0:;
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":224
- *
- * @cname('get_memview')
- * cdef get_memview(self): # <<<<<<<<<<<<<<
- * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE
- * return memoryview(self, flags, self.dtype_is_object)
- */
-
-static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) {
- int __pyx_v_flags;
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- PyObject *__pyx_t_1 = NULL;
- PyObject *__pyx_t_2 = NULL;
- PyObject *__pyx_t_3 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("get_memview", 0);
-
- /* "View.MemoryView":225
- * @cname('get_memview')
- * cdef get_memview(self):
- * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE # <<<<<<<<<<<<<<
- * return memoryview(self, flags, self.dtype_is_object)
- *
- */
- __pyx_v_flags = ((PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) | PyBUF_WRITABLE);
-
- /* "View.MemoryView":226
- * cdef get_memview(self):
- * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE
- * return memoryview(self, flags, self.dtype_is_object) # <<<<<<<<<<<<<<
- *
- * def __len__(self):
- */
- __Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 226, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 226, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 226, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_3);
- __Pyx_INCREF((PyObject *)__pyx_v_self);
- __Pyx_GIVEREF((PyObject *)__pyx_v_self);
- PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self));
- __Pyx_GIVEREF(__pyx_t_1);
- PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1);
- __Pyx_GIVEREF(__pyx_t_2);
- PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2);
- __pyx_t_1 = 0;
- __pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 226, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_2);
- __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_r = __pyx_t_2;
- __pyx_t_2 = 0;
- goto __pyx_L0;
-
- /* "View.MemoryView":224
- *
- * @cname('get_memview')
- * cdef get_memview(self): # <<<<<<<<<<<<<<
- * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE
- * return memoryview(self, flags, self.dtype_is_object)
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_1);
- __Pyx_XDECREF(__pyx_t_2);
- __Pyx_XDECREF(__pyx_t_3);
- __Pyx_AddTraceback("View.MemoryView.array.get_memview", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = 0;
- __pyx_L0:;
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":228
- * return memoryview(self, flags, self.dtype_is_object)
- *
- * def __len__(self): # <<<<<<<<<<<<<<
- * return self._shape[0]
- *
- */
-
-/* Python wrapper */
-static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self); /*proto*/
-static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- Py_ssize_t __pyx_r;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__len__ (wrapper)", 0);
- __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(((struct __pyx_array_obj *)__pyx_v_self));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self) {
- Py_ssize_t __pyx_r;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__len__", 0);
-
- /* "View.MemoryView":229
- *
- * def __len__(self):
- * return self._shape[0] # <<<<<<<<<<<<<<
- *
- * def __getattr__(self, attr):
- */
- __pyx_r = (__pyx_v_self->_shape[0]);
- goto __pyx_L0;
-
- /* "View.MemoryView":228
- * return memoryview(self, flags, self.dtype_is_object)
- *
- * def __len__(self): # <<<<<<<<<<<<<<
- * return self._shape[0]
- *
- */
-
- /* function exit code */
- __pyx_L0:;
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":231
- * return self._shape[0]
- *
- * def __getattr__(self, attr): # <<<<<<<<<<<<<<
- * return getattr(self.memview, attr)
- *
- */
-
-/* Python wrapper */
-static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr); /*proto*/
-static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- PyObject *__pyx_r = 0;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0);
- __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_attr));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr) {
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- PyObject *__pyx_t_1 = NULL;
- PyObject *__pyx_t_2 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("__getattr__", 0);
-
- /* "View.MemoryView":232
- *
- * def __getattr__(self, attr):
- * return getattr(self.memview, attr) # <<<<<<<<<<<<<<
- *
- * def __getitem__(self, item):
- */
- __Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 232, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_GetAttr(__pyx_t_1, __pyx_v_attr); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 232, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_2);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_r = __pyx_t_2;
- __pyx_t_2 = 0;
- goto __pyx_L0;
-
- /* "View.MemoryView":231
- * return self._shape[0]
- *
- * def __getattr__(self, attr): # <<<<<<<<<<<<<<
- * return getattr(self.memview, attr)
- *
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_1);
- __Pyx_XDECREF(__pyx_t_2);
- __Pyx_AddTraceback("View.MemoryView.array.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = NULL;
- __pyx_L0:;
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":234
- * return getattr(self.memview, attr)
- *
- * def __getitem__(self, item): # <<<<<<<<<<<<<<
- * return self.memview[item]
- *
- */
-
-/* Python wrapper */
-static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item); /*proto*/
-static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- PyObject *__pyx_r = 0;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0);
- __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item) {
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- PyObject *__pyx_t_1 = NULL;
- PyObject *__pyx_t_2 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("__getitem__", 0);
-
- /* "View.MemoryView":235
- *
- * def __getitem__(self, item):
- * return self.memview[item] # <<<<<<<<<<<<<<
- *
- * def __setitem__(self, item, value):
- */
- __Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 235, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 235, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_2);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_r = __pyx_t_2;
- __pyx_t_2 = 0;
- goto __pyx_L0;
-
- /* "View.MemoryView":234
- * return getattr(self.memview, attr)
- *
- * def __getitem__(self, item): # <<<<<<<<<<<<<<
- * return self.memview[item]
- *
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_1);
- __Pyx_XDECREF(__pyx_t_2);
- __Pyx_AddTraceback("View.MemoryView.array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = NULL;
- __pyx_L0:;
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":237
- * return self.memview[item]
- *
- * def __setitem__(self, item, value): # <<<<<<<<<<<<<<
- * self.memview[item] = value
- *
- */
-
-/* Python wrapper */
-static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /*proto*/
-static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- int __pyx_r;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0);
- __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item), ((PyObject *)__pyx_v_value));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) {
- int __pyx_r;
- __Pyx_RefNannyDeclarations
- PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("__setitem__", 0);
-
- /* "View.MemoryView":238
- *
- * def __setitem__(self, item, value):
- * self.memview[item] = value # <<<<<<<<<<<<<<
- *
- *
- */
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 238, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_v_item, __pyx_v_value) < 0))) __PYX_ERR(1, 238, __pyx_L1_error)
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
- /* "View.MemoryView":237
- * return self.memview[item]
- *
- * def __setitem__(self, item, value): # <<<<<<<<<<<<<<
- * self.memview[item] = value
- *
- */
-
- /* function exit code */
- __pyx_r = 0;
- goto __pyx_L0;
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_1);
- __Pyx_AddTraceback("View.MemoryView.array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = -1;
- __pyx_L0:;
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "(tree fragment)":1
- * def __reduce_cython__(self): # <<<<<<<<<<<<<<
- * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
- * def __setstate_cython__(self, __pyx_state):
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self,
-#if CYTHON_METH_FASTCALL
-PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
-#else
-PyObject *__pyx_args, PyObject *__pyx_kwds
-#endif
-); /*proto*/
-static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self,
-#if CYTHON_METH_FASTCALL
-PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
-#else
-PyObject *__pyx_args, PyObject *__pyx_kwds
-#endif
-) {
- #if !CYTHON_METH_FASTCALL
- CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
- #endif
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
- PyObject *__pyx_r = 0;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
- if (unlikely(__pyx_nargs > 0)) {
- __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
- if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
- __pyx_r = __pyx_pf___pyx_array___reduce_cython__(((struct __pyx_array_obj *)__pyx_v_self));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self) {
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("__reduce_cython__", 0);
-
- /* "(tree fragment)":2
- * def __reduce_cython__(self):
- * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
- */
- __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
- __PYX_ERR(1, 2, __pyx_L1_error)
-
- /* "(tree fragment)":1
- * def __reduce_cython__(self): # <<<<<<<<<<<<<<
- * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
- * def __setstate_cython__(self, __pyx_state):
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_AddTraceback("View.MemoryView.array.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = NULL;
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "(tree fragment)":3
- * def __reduce_cython__(self):
- * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
- * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
- * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self,
-#if CYTHON_METH_FASTCALL
-PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
-#else
-PyObject *__pyx_args, PyObject *__pyx_kwds
-#endif
-); /*proto*/
-static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self,
-#if CYTHON_METH_FASTCALL
-PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
-#else
-PyObject *__pyx_args, PyObject *__pyx_kwds
-#endif
-) {
- CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
- #if !CYTHON_METH_FASTCALL
- CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
- #endif
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- PyObject *__pyx_r = 0;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
- {
- PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
- PyObject* values[1] = {0};
- if (__pyx_kwds) {
- Py_ssize_t kw_args;
- switch (__pyx_nargs) {
- case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
- CYTHON_FALLTHROUGH;
- case 0: break;
- default: goto __pyx_L5_argtuple_error;
- }
- kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
- switch (__pyx_nargs) {
- case 0:
- if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) kw_args--;
- else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error)
- else goto __pyx_L5_argtuple_error;
- }
- if (unlikely(kw_args > 0)) {
- const Py_ssize_t kwd_pos_args = __pyx_nargs;
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error)
- }
- } else if (unlikely(__pyx_nargs != 1)) {
- goto __pyx_L5_argtuple_error;
- } else {
- values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
- }
- __pyx_v___pyx_state = values[0];
- }
- goto __pyx_L4_argument_unpacking_done;
- __pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
- __pyx_L3_error:;
- __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __Pyx_RefNannyFinishContext();
- return NULL;
- __pyx_L4_argument_unpacking_done:;
- __pyx_r = __pyx_pf___pyx_array_2__setstate_cython__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v___pyx_state);
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("__setstate_cython__", 0);
-
- /* "(tree fragment)":4
- * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
- * def __setstate_cython__(self, __pyx_state):
- * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<<
- */
- __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
- __PYX_ERR(1, 4, __pyx_L1_error)
-
- /* "(tree fragment)":3
- * def __reduce_cython__(self):
- * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
- * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
- * raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = NULL;
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":248
- *
- * @cname("__pyx_array_allocate_buffer")
- * cdef int _allocate_buffer(array self) except -1: # <<<<<<<<<<<<<<
- *
- *
- */
-
-static int __pyx_array_allocate_buffer(struct __pyx_array_obj *__pyx_v_self) {
- Py_ssize_t __pyx_v_i;
- PyObject **__pyx_v_p;
- int __pyx_r;
- __Pyx_RefNannyDeclarations
- int __pyx_t_1;
- Py_ssize_t __pyx_t_2;
- Py_ssize_t __pyx_t_3;
- Py_ssize_t __pyx_t_4;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("_allocate_buffer", 0);
-
- /* "View.MemoryView":254
- * cdef PyObject **p
- *
- * self.free_data = True # <<<<<<<<<<<<<<
- * self.data = malloc(self.len)
- * if not self.data:
- */
- __pyx_v_self->free_data = 1;
-
- /* "View.MemoryView":255
- *
- * self.free_data = True
- * self.data = malloc(self.len) # <<<<<<<<<<<<<<
- * if not self.data:
- * raise MemoryError, "unable to allocate array data."
- */
- __pyx_v_self->data = ((char *)malloc(__pyx_v_self->len));
-
- /* "View.MemoryView":256
- * self.free_data = True
- * self.data = malloc(self.len)
- * if not self.data: # <<<<<<<<<<<<<<
- * raise MemoryError, "unable to allocate array data."
- *
- */
- __pyx_t_1 = (!(__pyx_v_self->data != 0));
- if (unlikely(__pyx_t_1)) {
-
- /* "View.MemoryView":257
- * self.data = malloc(self.len)
- * if not self.data:
- * raise MemoryError, "unable to allocate array data." # <<<<<<<<<<<<<<
- *
- * if self.dtype_is_object:
- */
- __Pyx_Raise(__pyx_builtin_MemoryError, __pyx_kp_s_unable_to_allocate_array_data, 0, 0);
- __PYX_ERR(1, 257, __pyx_L1_error)
-
- /* "View.MemoryView":256
- * self.free_data = True
- * self.data = malloc(self.len)
- * if not self.data: # <<<<<<<<<<<<<<
- * raise MemoryError, "unable to allocate array data."
- *
- */
- }
-
- /* "View.MemoryView":259
- * raise MemoryError, "unable to allocate array data."
- *
- * if self.dtype_is_object: # <<<<<<<<<<<<<<
- * p = self.data
- * for i in range(self.len // self.itemsize):
- */
- if (__pyx_v_self->dtype_is_object) {
-
- /* "View.MemoryView":260
- *
- * if self.dtype_is_object:
- * p = self.data # <<<<<<<<<<<<<<
- * for i in range(self.len // self.itemsize):
- * p[i] = Py_None
- */
- __pyx_v_p = ((PyObject **)__pyx_v_self->data);
-
- /* "View.MemoryView":261
- * if self.dtype_is_object:
- * p = self.data
- * for i in range(self.len // self.itemsize): # <<<<<<<<<<<<<<
- * p[i] = Py_None
- * Py_INCREF(Py_None)
- */
- if (unlikely(__pyx_v_self->itemsize == 0)) {
- PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero");
- __PYX_ERR(1, 261, __pyx_L1_error)
- }
- else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_self->itemsize == (Py_ssize_t)-1) && unlikely(__Pyx_UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) {
- PyErr_SetString(PyExc_OverflowError, "value too large to perform division");
- __PYX_ERR(1, 261, __pyx_L1_error)
- }
- __pyx_t_2 = __Pyx_div_Py_ssize_t(__pyx_v_self->len, __pyx_v_self->itemsize);
- __pyx_t_3 = __pyx_t_2;
- for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
- __pyx_v_i = __pyx_t_4;
-
- /* "View.MemoryView":262
- * p = self.data
- * for i in range(self.len // self.itemsize):
- * p[i] = Py_None # <<<<<<<<<<<<<<
- * Py_INCREF(Py_None)
- * return 0
- */
- (__pyx_v_p[__pyx_v_i]) = Py_None;
-
- /* "View.MemoryView":263
- * for i in range(self.len // self.itemsize):
- * p[i] = Py_None
- * Py_INCREF(Py_None) # <<<<<<<<<<<<<<
- * return 0
- *
- */
- Py_INCREF(Py_None);
- }
-
- /* "View.MemoryView":259
- * raise MemoryError, "unable to allocate array data."
- *
- * if self.dtype_is_object: # <<<<<<<<<<<<<<
- * p = self.data
- * for i in range(self.len // self.itemsize):
- */
- }
-
- /* "View.MemoryView":264
- * p[i] = Py_None
- * Py_INCREF(Py_None)
- * return 0 # <<<<<<<<<<<<<<
- *
- *
- */
- __pyx_r = 0;
- goto __pyx_L0;
-
- /* "View.MemoryView":248
- *
- * @cname("__pyx_array_allocate_buffer")
- * cdef int _allocate_buffer(array self) except -1: # <<<<<<<<<<<<<<
- *
- *
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_AddTraceback("View.MemoryView._allocate_buffer", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = -1;
- __pyx_L0:;
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":268
- *
- * @cname("__pyx_array_new")
- * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, char *c_mode, char *buf): # <<<<<<<<<<<<<<
- * cdef array result
- * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string.
- */
-
-static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, char *__pyx_v_format, char *__pyx_v_c_mode, char *__pyx_v_buf) {
- struct __pyx_array_obj *__pyx_v_result = 0;
- PyObject *__pyx_v_mode = 0;
- struct __pyx_array_obj *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- PyObject *__pyx_t_1 = NULL;
- int __pyx_t_2;
- PyObject *__pyx_t_3 = NULL;
- PyObject *__pyx_t_4 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("array_cwrapper", 0);
-
- /* "View.MemoryView":270
- * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, char *c_mode, char *buf):
- * cdef array result
- * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. # <<<<<<<<<<<<<<
- *
- * if buf is NULL:
- */
- if (((__pyx_v_c_mode[0]) == 'f')) {
- __Pyx_INCREF(__pyx_n_s_fortran);
- __pyx_t_1 = __pyx_n_s_fortran;
- } else {
- __Pyx_INCREF(__pyx_n_s_c);
- __pyx_t_1 = __pyx_n_s_c;
- }
- __pyx_v_mode = ((PyObject*)__pyx_t_1);
- __pyx_t_1 = 0;
-
- /* "View.MemoryView":272
- * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string.
- *
- * if buf is NULL: # <<<<<<<<<<<<<<
- * result = array.__new__(array, shape, itemsize, format, mode)
- * else:
- */
- __pyx_t_2 = (__pyx_v_buf == NULL);
- if (__pyx_t_2) {
-
- /* "View.MemoryView":273
- *
- * if buf is NULL:
- * result = array.__new__(array, shape, itemsize, format, mode) # <<<<<<<<<<<<<<
- * else:
- * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False)
- */
- __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 273, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 273, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 273, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_4);
- __Pyx_INCREF(__pyx_v_shape);
- __Pyx_GIVEREF(__pyx_v_shape);
- PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_shape);
- __Pyx_GIVEREF(__pyx_t_1);
- PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1);
- __Pyx_GIVEREF(__pyx_t_3);
- PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3);
- __Pyx_INCREF(__pyx_v_mode);
- __Pyx_GIVEREF(__pyx_v_mode);
- PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_v_mode);
- __pyx_t_1 = 0;
- __pyx_t_3 = 0;
- __pyx_t_3 = ((PyObject *)__pyx_tp_new_array(((PyTypeObject *)__pyx_array_type), __pyx_t_4, NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 273, __pyx_L1_error)
- __Pyx_GOTREF((PyObject *)__pyx_t_3);
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_3);
- __pyx_t_3 = 0;
-
- /* "View.MemoryView":272
- * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string.
- *
- * if buf is NULL: # <<<<<<<<<<<<<<
- * result = array.__new__(array, shape, itemsize, format, mode)
- * else:
- */
- goto __pyx_L3;
- }
-
- /* "View.MemoryView":275
- * result = array.__new__(array, shape, itemsize, format, mode)
- * else:
- * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) # <<<<<<<<<<<<<<
- * result.data = buf
- *
- */
- /*else*/ {
- __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 275, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 275, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_4);
- __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 275, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __Pyx_INCREF(__pyx_v_shape);
- __Pyx_GIVEREF(__pyx_v_shape);
- PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_shape);
- __Pyx_GIVEREF(__pyx_t_3);
- PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3);
- __Pyx_GIVEREF(__pyx_t_4);
- PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_t_4);
- __Pyx_INCREF(__pyx_v_mode);
- __Pyx_GIVEREF(__pyx_v_mode);
- PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_v_mode);
- __pyx_t_3 = 0;
- __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 275, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_4);
- if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_allocate_buffer, Py_False) < 0) __PYX_ERR(1, 275, __pyx_L1_error)
- __pyx_t_3 = ((PyObject *)__pyx_tp_new_array(((PyTypeObject *)__pyx_array_type), __pyx_t_1, __pyx_t_4)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 275, __pyx_L1_error)
- __Pyx_GOTREF((PyObject *)__pyx_t_3);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_3);
- __pyx_t_3 = 0;
-
- /* "View.MemoryView":276
- * else:
- * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False)
- * result.data = buf # <<<<<<<<<<<<<<
- *
- * return result
- */
- __pyx_v_result->data = __pyx_v_buf;
- }
- __pyx_L3:;
-
- /* "View.MemoryView":278
- * result.data = buf
- *
- * return result # <<<<<<<<<<<<<<
- *
- *
- */
- __Pyx_XDECREF((PyObject *)__pyx_r);
- __Pyx_INCREF((PyObject *)__pyx_v_result);
- __pyx_r = __pyx_v_result;
- goto __pyx_L0;
-
- /* "View.MemoryView":268
- *
- * @cname("__pyx_array_new")
- * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, char *c_mode, char *buf): # <<<<<<<<<<<<<<
- * cdef array result
- * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string.
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_1);
- __Pyx_XDECREF(__pyx_t_3);
- __Pyx_XDECREF(__pyx_t_4);
- __Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = 0;
- __pyx_L0:;
- __Pyx_XDECREF((PyObject *)__pyx_v_result);
- __Pyx_XDECREF(__pyx_v_mode);
- __Pyx_XGIVEREF((PyObject *)__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":304
- * cdef class Enum(object):
- * cdef object name
- * def __init__(self, name): # <<<<<<<<<<<<<<
- * self.name = name
- * def __repr__(self):
- */
-
-/* Python wrapper */
-static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
- PyObject *__pyx_v_name = 0;
- CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- int __pyx_r;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
- {
- PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0};
- PyObject* values[1] = {0};
- if (__pyx_kwds) {
- Py_ssize_t kw_args;
- switch (__pyx_nargs) {
- case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
- CYTHON_FALLTHROUGH;
- case 0: break;
- default: goto __pyx_L5_argtuple_error;
- }
- kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds);
- switch (__pyx_nargs) {
- case 0:
- if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) kw_args--;
- else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 304, __pyx_L3_error)
- else goto __pyx_L5_argtuple_error;
- }
- if (unlikely(kw_args > 0)) {
- const Py_ssize_t kwd_pos_args = __pyx_nargs;
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(1, 304, __pyx_L3_error)
- }
- } else if (unlikely(__pyx_nargs != 1)) {
- goto __pyx_L5_argtuple_error;
- } else {
- values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
- }
- __pyx_v_name = values[0];
- }
- goto __pyx_L4_argument_unpacking_done;
- __pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 304, __pyx_L3_error)
- __pyx_L3_error:;
- __Pyx_AddTraceback("View.MemoryView.Enum.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __Pyx_RefNannyFinishContext();
- return -1;
- __pyx_L4_argument_unpacking_done:;
- __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v_name);
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name) {
- int __pyx_r;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__init__", 0);
-
- /* "View.MemoryView":305
- * cdef object name
- * def __init__(self, name):
- * self.name = name # <<<<<<<<<<<<<<
- * def __repr__(self):
- * return self.name
- */
- __Pyx_INCREF(__pyx_v_name);
- __Pyx_GIVEREF(__pyx_v_name);
- __Pyx_GOTREF(__pyx_v_self->name);
- __Pyx_DECREF(__pyx_v_self->name);
- __pyx_v_self->name = __pyx_v_name;
-
- /* "View.MemoryView":304
- * cdef class Enum(object):
- * cdef object name
- * def __init__(self, name): # <<<<<<<<<<<<<<
- * self.name = name
- * def __repr__(self):
- */
-
- /* function exit code */
- __pyx_r = 0;
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":306
- * def __init__(self, name):
- * self.name = name
- * def __repr__(self): # <<<<<<<<<<<<<<
- * return self.name
- *
- */
-
-/* Python wrapper */
-static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- PyObject *__pyx_r = 0;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
- __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self) {
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__repr__", 0);
-
- /* "View.MemoryView":307
- * self.name = name
- * def __repr__(self):
- * return self.name # <<<<<<<<<<<<<<
- *
- * cdef generic = Enum("")
- */
- __Pyx_XDECREF(__pyx_r);
- __Pyx_INCREF(__pyx_v_self->name);
- __pyx_r = __pyx_v_self->name;
- goto __pyx_L0;
-
- /* "View.MemoryView":306
- * def __init__(self, name):
- * self.name = name
- * def __repr__(self): # <<<<<<<<<<<<<<
- * return self.name
- *
- */
-
- /* function exit code */
- __pyx_L0:;
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "(tree fragment)":1
- * def __reduce_cython__(self): # <<<<<<<<<<<<<<
- * cdef tuple state
- * cdef object _dict
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self,
-#if CYTHON_METH_FASTCALL
-PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
-#else
-PyObject *__pyx_args, PyObject *__pyx_kwds
-#endif
-); /*proto*/
-static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self,
-#if CYTHON_METH_FASTCALL
-PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
-#else
-PyObject *__pyx_args, PyObject *__pyx_kwds
-#endif
-) {
- #if !CYTHON_METH_FASTCALL
- CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
- #endif
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
- PyObject *__pyx_r = 0;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
- if (unlikely(__pyx_nargs > 0)) {
- __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
- if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
- __pyx_r = __pyx_pf___pyx_MemviewEnum___reduce_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self) {
- PyObject *__pyx_v_state = 0;
- PyObject *__pyx_v__dict = 0;
- int __pyx_v_use_setstate;
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- PyObject *__pyx_t_1 = NULL;
- int __pyx_t_2;
- PyObject *__pyx_t_3 = NULL;
- PyObject *__pyx_t_4 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("__reduce_cython__", 0);
-
- /* "(tree fragment)":5
- * cdef object _dict
- * cdef bint use_setstate
- * state = (self.name,) # <<<<<<<<<<<<<<
- * _dict = getattr(self, '__dict__', None)
- * if _dict is not None:
- */
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __Pyx_INCREF(__pyx_v_self->name);
- __Pyx_GIVEREF(__pyx_v_self->name);
- PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name);
- __pyx_v_state = ((PyObject*)__pyx_t_1);
- __pyx_t_1 = 0;
-
- /* "(tree fragment)":6
- * cdef bint use_setstate
- * state = (self.name,)
- * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<<
- * if _dict is not None:
- * state += (_dict,)
- */
- __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_v__dict = __pyx_t_1;
- __pyx_t_1 = 0;
-
- /* "(tree fragment)":7
- * state = (self.name,)
- * _dict = getattr(self, '__dict__', None)
- * if _dict is not None: # <<<<<<<<<<<<<<
- * state += (_dict,)
- * use_setstate = True
- */
- __pyx_t_2 = (__pyx_v__dict != Py_None);
- if (__pyx_t_2) {
-
- /* "(tree fragment)":8
- * _dict = getattr(self, '__dict__', None)
- * if _dict is not None:
- * state += (_dict,) # <<<<<<<<<<<<<<
- * use_setstate = True
- * else:
- */
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __Pyx_INCREF(__pyx_v__dict);
- __Pyx_GIVEREF(__pyx_v__dict);
- PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict);
- __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 8, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_3);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3));
- __pyx_t_3 = 0;
-
- /* "(tree fragment)":9
- * if _dict is not None:
- * state += (_dict,)
- * use_setstate = True # <<<<<<<<<<<<<<
- * else:
- * use_setstate = self.name is not None
- */
- __pyx_v_use_setstate = 1;
-
- /* "(tree fragment)":7
- * state = (self.name,)
- * _dict = getattr(self, '__dict__', None)
- * if _dict is not None: # <<<<<<<<<<<<<<
- * state += (_dict,)
- * use_setstate = True
- */
- goto __pyx_L3;
- }
-
- /* "(tree fragment)":11
- * use_setstate = True
- * else:
- * use_setstate = self.name is not None # <<<<<<<<<<<<<<
- * if use_setstate:
- * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state
- */
- /*else*/ {
- __pyx_t_2 = (__pyx_v_self->name != Py_None);
- __pyx_v_use_setstate = __pyx_t_2;
- }
- __pyx_L3:;
-
- /* "(tree fragment)":12
- * else:
- * use_setstate = self.name is not None
- * if use_setstate: # <<<<<<<<<<<<<<
- * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state
- * else:
- */
- if (__pyx_v_use_setstate) {
-
- /* "(tree fragment)":13
- * use_setstate = self.name is not None
- * if use_setstate:
- * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state # <<<<<<<<<<<<<<
- * else:
- * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state)
- */
- __Pyx_XDECREF(__pyx_r);
- __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_3);
- __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
- __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
- PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
- __Pyx_INCREF(__pyx_int_136983863);
- __Pyx_GIVEREF(__pyx_int_136983863);
- PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_136983863);
- __Pyx_INCREF(Py_None);
- __Pyx_GIVEREF(Py_None);
- PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None);
- __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_4);
- __Pyx_GIVEREF(__pyx_t_3);
- PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
- __Pyx_GIVEREF(__pyx_t_1);
- PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1);
- __Pyx_INCREF(__pyx_v_state);
- __Pyx_GIVEREF(__pyx_v_state);
- PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state);
- __pyx_t_3 = 0;
- __pyx_t_1 = 0;
- __pyx_r = __pyx_t_4;
- __pyx_t_4 = 0;
- goto __pyx_L0;
-
- /* "(tree fragment)":12
- * else:
- * use_setstate = self.name is not None
- * if use_setstate: # <<<<<<<<<<<<<<
- * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state
- * else:
- */
- }
-
- /* "(tree fragment)":15
- * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state
- * else:
- * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- * __pyx_unpickle_Enum__set_state(self, __pyx_state)
- */
- /*else*/ {
- __Pyx_XDECREF(__pyx_r);
- __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_4);
- __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
- __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
- PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
- __Pyx_INCREF(__pyx_int_136983863);
- __Pyx_GIVEREF(__pyx_int_136983863);
- PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_136983863);
- __Pyx_INCREF(__pyx_v_state);
- __Pyx_GIVEREF(__pyx_v_state);
- PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state);
- __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_3);
- __Pyx_GIVEREF(__pyx_t_4);
- PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
- __Pyx_GIVEREF(__pyx_t_1);
- PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1);
- __pyx_t_4 = 0;
- __pyx_t_1 = 0;
- __pyx_r = __pyx_t_3;
- __pyx_t_3 = 0;
- goto __pyx_L0;
- }
-
- /* "(tree fragment)":1
- * def __reduce_cython__(self): # <<<<<<<<<<<<<<
- * cdef tuple state
- * cdef object _dict
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_1);
- __Pyx_XDECREF(__pyx_t_3);
- __Pyx_XDECREF(__pyx_t_4);
- __Pyx_AddTraceback("View.MemoryView.Enum.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = NULL;
- __pyx_L0:;
- __Pyx_XDECREF(__pyx_v_state);
- __Pyx_XDECREF(__pyx_v__dict);
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "(tree fragment)":16
- * else:
- * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state)
- * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
- * __pyx_unpickle_Enum__set_state(self, __pyx_state)
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self,
-#if CYTHON_METH_FASTCALL
-PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
-#else
-PyObject *__pyx_args, PyObject *__pyx_kwds
-#endif
-); /*proto*/
-static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self,
-#if CYTHON_METH_FASTCALL
-PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
-#else
-PyObject *__pyx_args, PyObject *__pyx_kwds
-#endif
-) {
- PyObject *__pyx_v___pyx_state = 0;
- #if !CYTHON_METH_FASTCALL
- CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
- #endif
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- PyObject *__pyx_r = 0;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
- {
- PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
- PyObject* values[1] = {0};
- if (__pyx_kwds) {
- Py_ssize_t kw_args;
- switch (__pyx_nargs) {
- case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
- CYTHON_FALLTHROUGH;
- case 0: break;
- default: goto __pyx_L5_argtuple_error;
- }
- kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
- switch (__pyx_nargs) {
- case 0:
- if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) kw_args--;
- else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 16, __pyx_L3_error)
- else goto __pyx_L5_argtuple_error;
- }
- if (unlikely(kw_args > 0)) {
- const Py_ssize_t kwd_pos_args = __pyx_nargs;
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 16, __pyx_L3_error)
- }
- } else if (unlikely(__pyx_nargs != 1)) {
- goto __pyx_L5_argtuple_error;
- } else {
- values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
- }
- __pyx_v___pyx_state = values[0];
- }
- goto __pyx_L4_argument_unpacking_done;
- __pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error)
- __pyx_L3_error:;
- __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __Pyx_RefNannyFinishContext();
- return NULL;
- __pyx_L4_argument_unpacking_done:;
- __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v___pyx_state);
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("__setstate_cython__", 0);
-
- /* "(tree fragment)":17
- * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state)
- * def __setstate_cython__(self, __pyx_state):
- * __pyx_unpickle_Enum__set_state(self, __pyx_state) # <<<<<<<<<<<<<<
- */
- if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 17, __pyx_L1_error)
- __pyx_t_1 = __pyx_unpickle_Enum__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
- /* "(tree fragment)":16
- * else:
- * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state)
- * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<<
- * __pyx_unpickle_Enum__set_state(self, __pyx_state)
- */
-
- /* function exit code */
- __pyx_r = Py_None; __Pyx_INCREF(Py_None);
- goto __pyx_L0;
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_1);
- __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = NULL;
- __pyx_L0:;
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":349
- * cdef __Pyx_TypeInfo *typeinfo
- *
- * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<<
- * self.obj = obj
- * self.flags = flags
- */
-
-/* Python wrapper */
-static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
- PyObject *__pyx_v_obj = 0;
- int __pyx_v_flags;
- int __pyx_v_dtype_is_object;
- CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- int __pyx_r;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
- {
- PyObject **__pyx_pyargnames[] = {&__pyx_n_s_obj,&__pyx_n_s_flags,&__pyx_n_s_dtype_is_object,0};
- PyObject* values[3] = {0,0,0};
- if (__pyx_kwds) {
- Py_ssize_t kw_args;
- switch (__pyx_nargs) {
- case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2);
- CYTHON_FALLTHROUGH;
- case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1);
- CYTHON_FALLTHROUGH;
- case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
- CYTHON_FALLTHROUGH;
- case 0: break;
- default: goto __pyx_L5_argtuple_error;
- }
- kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds);
- switch (__pyx_nargs) {
- case 0:
- if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_obj)) != 0)) kw_args--;
- else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error)
- else goto __pyx_L5_argtuple_error;
- CYTHON_FALLTHROUGH;
- case 1:
- if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_flags)) != 0)) kw_args--;
- else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error)
- else {
- __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(1, 349, __pyx_L3_error)
- }
- CYTHON_FALLTHROUGH;
- case 2:
- if (kw_args > 0) {
- PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dtype_is_object);
- if (value) { values[2] = value; kw_args--; }
- else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error)
- }
- }
- if (unlikely(kw_args > 0)) {
- const Py_ssize_t kwd_pos_args = __pyx_nargs;
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(1, 349, __pyx_L3_error)
- }
- } else {
- switch (__pyx_nargs) {
- case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2);
- CYTHON_FALLTHROUGH;
- case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1);
- values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
- break;
- default: goto __pyx_L5_argtuple_error;
- }
- }
- __pyx_v_obj = values[0];
- __pyx_v_flags = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error)
- if (values[2]) {
- __pyx_v_dtype_is_object = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_dtype_is_object == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error)
- } else {
- __pyx_v_dtype_is_object = ((int)0);
- }
- }
- goto __pyx_L4_argument_unpacking_done;
- __pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, __pyx_nargs); __PYX_ERR(1, 349, __pyx_L3_error)
- __pyx_L3_error:;
- __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __Pyx_RefNannyFinishContext();
- return -1;
- __pyx_L4_argument_unpacking_done:;
- __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_obj, __pyx_v_flags, __pyx_v_dtype_is_object);
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object) {
- int __pyx_r;
- __Pyx_RefNannyDeclarations
- int __pyx_t_1;
- int __pyx_t_2;
- int __pyx_t_3;
- Py_intptr_t __pyx_t_4;
- size_t __pyx_t_5;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("__cinit__", 0);
-
- /* "View.MemoryView":350
- *
- * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False):
- * self.obj = obj # <<<<<<<<<<<<<<
- * self.flags = flags
- * if type(self) is memoryview or obj is not None:
- */
- __Pyx_INCREF(__pyx_v_obj);
- __Pyx_GIVEREF(__pyx_v_obj);
- __Pyx_GOTREF(__pyx_v_self->obj);
- __Pyx_DECREF(__pyx_v_self->obj);
- __pyx_v_self->obj = __pyx_v_obj;
-
- /* "View.MemoryView":351
- * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False):
- * self.obj = obj
- * self.flags = flags # <<<<<<<<<<<<<<
- * if type(self) is memoryview or obj is not None:
- * __Pyx_GetBuffer(obj, &self.view, flags)
- */
- __pyx_v_self->flags = __pyx_v_flags;
-
- /* "View.MemoryView":352
- * self.obj = obj
- * self.flags = flags
- * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<<
- * __Pyx_GetBuffer(obj, &self.view, flags)
- * if self.view.obj == NULL:
- */
- __pyx_t_2 = (((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))) == ((PyObject *)__pyx_memoryview_type));
- if (!__pyx_t_2) {
- } else {
- __pyx_t_1 = __pyx_t_2;
- goto __pyx_L4_bool_binop_done;
- }
- __pyx_t_2 = (__pyx_v_obj != Py_None);
- __pyx_t_1 = __pyx_t_2;
- __pyx_L4_bool_binop_done:;
- if (__pyx_t_1) {
-
- /* "View.MemoryView":353
- * self.flags = flags
- * if type(self) is memoryview or obj is not None:
- * __Pyx_GetBuffer(obj, &self.view, flags) # <<<<<<<<<<<<<<
- * if self.view.obj == NULL:
- * (<__pyx_buffer *> &self.view).obj = Py_None
- */
- __pyx_t_3 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 353, __pyx_L1_error)
-
- /* "View.MemoryView":354
- * if type(self) is memoryview or obj is not None:
- * __Pyx_GetBuffer(obj, &self.view, flags)
- * if self.view.obj == NULL: # <<<<<<<<<<<<<<
- * (<__pyx_buffer *> &self.view).obj = Py_None
- * Py_INCREF(Py_None)
- */
- __pyx_t_1 = (((PyObject *)__pyx_v_self->view.obj) == NULL);
- if (__pyx_t_1) {
-
- /* "View.MemoryView":355
- * __Pyx_GetBuffer(obj, &self.view, flags)
- * if self.view.obj == NULL:
- * (<__pyx_buffer *> &self.view).obj = Py_None # <<<<<<<<<<<<<<
- * Py_INCREF(Py_None)
- *
- */
- ((Py_buffer *)(&__pyx_v_self->view))->obj = Py_None;
-
- /* "View.MemoryView":356
- * if self.view.obj == NULL:
- * (<__pyx_buffer *> &self.view).obj = Py_None
- * Py_INCREF(Py_None) # <<<<<<<<<<<<<<
- *
- * if not __PYX_CYTHON_ATOMICS_ENABLED():
- */
- Py_INCREF(Py_None);
-
- /* "View.MemoryView":354
- * if type(self) is memoryview or obj is not None:
- * __Pyx_GetBuffer(obj, &self.view, flags)
- * if self.view.obj == NULL: # <<<<<<<<<<<<<<
- * (<__pyx_buffer *> &self.view).obj = Py_None
- * Py_INCREF(Py_None)
- */
- }
-
- /* "View.MemoryView":352
- * self.obj = obj
- * self.flags = flags
- * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<<
- * __Pyx_GetBuffer(obj, &self.view, flags)
- * if self.view.obj == NULL:
- */
- }
-
- /* "View.MemoryView":358
- * Py_INCREF(Py_None)
- *
- * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<<
- * global __pyx_memoryview_thread_locks_used
- * if __pyx_memoryview_thread_locks_used < 8:
- */
- __pyx_t_1 = (!__PYX_CYTHON_ATOMICS_ENABLED());
- if (__pyx_t_1) {
-
- /* "View.MemoryView":360
- * if not __PYX_CYTHON_ATOMICS_ENABLED():
- * global __pyx_memoryview_thread_locks_used
- * if __pyx_memoryview_thread_locks_used < 8: # <<<<<<<<<<<<<<
- * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
- * __pyx_memoryview_thread_locks_used += 1
- */
- __pyx_t_1 = (__pyx_memoryview_thread_locks_used < 8);
- if (__pyx_t_1) {
-
- /* "View.MemoryView":361
- * global __pyx_memoryview_thread_locks_used
- * if __pyx_memoryview_thread_locks_used < 8:
- * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] # <<<<<<<<<<<<<<
- * __pyx_memoryview_thread_locks_used += 1
- * if self.lock is NULL:
- */
- __pyx_v_self->lock = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]);
-
- /* "View.MemoryView":362
- * if __pyx_memoryview_thread_locks_used < 8:
- * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
- * __pyx_memoryview_thread_locks_used += 1 # <<<<<<<<<<<<<<
- * if self.lock is NULL:
- * self.lock = PyThread_allocate_lock()
- */
- __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used + 1);
-
- /* "View.MemoryView":360
- * if not __PYX_CYTHON_ATOMICS_ENABLED():
- * global __pyx_memoryview_thread_locks_used
- * if __pyx_memoryview_thread_locks_used < 8: # <<<<<<<<<<<<<<
- * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
- * __pyx_memoryview_thread_locks_used += 1
- */
- }
-
- /* "View.MemoryView":363
- * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
- * __pyx_memoryview_thread_locks_used += 1
- * if self.lock is NULL: # <<<<<<<<<<<<<<
- * self.lock = PyThread_allocate_lock()
- * if self.lock is NULL:
- */
- __pyx_t_1 = (__pyx_v_self->lock == NULL);
- if (__pyx_t_1) {
-
- /* "View.MemoryView":364
- * __pyx_memoryview_thread_locks_used += 1
- * if self.lock is NULL:
- * self.lock = PyThread_allocate_lock() # <<<<<<<<<<<<<<
- * if self.lock is NULL:
- * raise MemoryError
- */
- __pyx_v_self->lock = PyThread_allocate_lock();
-
- /* "View.MemoryView":365
- * if self.lock is NULL:
- * self.lock = PyThread_allocate_lock()
- * if self.lock is NULL: # <<<<<<<<<<<<<<
- * raise MemoryError
- *
- */
- __pyx_t_1 = (__pyx_v_self->lock == NULL);
- if (unlikely(__pyx_t_1)) {
-
- /* "View.MemoryView":366
- * self.lock = PyThread_allocate_lock()
- * if self.lock is NULL:
- * raise MemoryError # <<<<<<<<<<<<<<
- *
- * if flags & PyBUF_FORMAT:
- */
- PyErr_NoMemory(); __PYX_ERR(1, 366, __pyx_L1_error)
-
- /* "View.MemoryView":365
- * if self.lock is NULL:
- * self.lock = PyThread_allocate_lock()
- * if self.lock is NULL: # <<<<<<<<<<<<<<
- * raise MemoryError
- *
- */
- }
-
- /* "View.MemoryView":363
- * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
- * __pyx_memoryview_thread_locks_used += 1
- * if self.lock is NULL: # <<<<<<<<<<<<<<
- * self.lock = PyThread_allocate_lock()
- * if self.lock is NULL:
- */
- }
-
- /* "View.MemoryView":358
- * Py_INCREF(Py_None)
- *
- * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<<
- * global __pyx_memoryview_thread_locks_used
- * if __pyx_memoryview_thread_locks_used < 8:
- */
- }
-
- /* "View.MemoryView":368
- * raise MemoryError
- *
- * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<<
- * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0')
- * else:
- */
- __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0);
- if (__pyx_t_1) {
-
- /* "View.MemoryView":369
- *
- * if flags & PyBUF_FORMAT:
- * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') # <<<<<<<<<<<<<<
- * else:
- * self.dtype_is_object = dtype_is_object
- */
- __pyx_t_2 = ((__pyx_v_self->view.format[0]) == 'O');
- if (__pyx_t_2) {
- } else {
- __pyx_t_1 = __pyx_t_2;
- goto __pyx_L12_bool_binop_done;
- }
- __pyx_t_2 = ((__pyx_v_self->view.format[1]) == '\x00');
- __pyx_t_1 = __pyx_t_2;
- __pyx_L12_bool_binop_done:;
- __pyx_v_self->dtype_is_object = __pyx_t_1;
-
- /* "View.MemoryView":368
- * raise MemoryError
- *
- * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<<
- * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0')
- * else:
- */
- goto __pyx_L11;
- }
-
- /* "View.MemoryView":371
- * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0')
- * else:
- * self.dtype_is_object = dtype_is_object # <<<<<<<<<<<<<<
- *
- * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0
- */
- /*else*/ {
- __pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object;
- }
- __pyx_L11:;
-
- /* "View.MemoryView":373
- * self.dtype_is_object = dtype_is_object
- *
- * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0 # <<<<<<<<<<<<<<
- * self.typeinfo = NULL
- *
- */
- #ifndef CYTHON_WITHOUT_ASSERTIONS
- if (unlikely(__pyx_assertions_enabled())) {
- __pyx_t_4 = ((Py_intptr_t)((void *)(&__pyx_v_self->acquisition_count)));
- __pyx_t_5 = (sizeof(__pyx_atomic_int_type));
- if (unlikely(__pyx_t_5 == 0)) {
- PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero");
- __PYX_ERR(1, 373, __pyx_L1_error)
- }
- __pyx_t_1 = ((__pyx_t_4 % __pyx_t_5) == 0);
- if (unlikely(!__pyx_t_1)) {
- __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0);
- __PYX_ERR(1, 373, __pyx_L1_error)
- }
- }
- #else
- if ((1)); else __PYX_ERR(1, 373, __pyx_L1_error)
- #endif
-
- /* "View.MemoryView":374
- *
- * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0
- * self.typeinfo = NULL # <<<<<<<<<<<<<<
- *
- * def __dealloc__(memoryview self):
- */
- __pyx_v_self->typeinfo = NULL;
-
- /* "View.MemoryView":349
- * cdef __Pyx_TypeInfo *typeinfo
- *
- * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<<
- * self.obj = obj
- * self.flags = flags
- */
-
- /* function exit code */
- __pyx_r = 0;
- goto __pyx_L0;
- __pyx_L1_error:;
- __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = -1;
- __pyx_L0:;
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":376
- * self.typeinfo = NULL
- *
- * def __dealloc__(memoryview self): # <<<<<<<<<<<<<<
- * if self.obj is not None:
- * __Pyx_ReleaseBuffer(&self.view)
- */
-
-/* Python wrapper */
-static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self); /*proto*/
-static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
- __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
-}
-
-static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self) {
- int __pyx_v_i;
- __Pyx_RefNannyDeclarations
- int __pyx_t_1;
- int __pyx_t_2;
- int __pyx_t_3;
- int __pyx_t_4;
- PyThread_type_lock __pyx_t_5;
- PyThread_type_lock __pyx_t_6;
- __Pyx_RefNannySetupContext("__dealloc__", 0);
-
- /* "View.MemoryView":377
- *
- * def __dealloc__(memoryview self):
- * if self.obj is not None: # <<<<<<<<<<<<<<
- * __Pyx_ReleaseBuffer(&self.view)
- * elif (<__pyx_buffer *> &self.view).obj == Py_None:
- */
- __pyx_t_1 = (__pyx_v_self->obj != Py_None);
- if (__pyx_t_1) {
-
- /* "View.MemoryView":378
- * def __dealloc__(memoryview self):
- * if self.obj is not None:
- * __Pyx_ReleaseBuffer(&self.view) # <<<<<<<<<<<<<<
- * elif (<__pyx_buffer *> &self.view).obj == Py_None:
- *
- */
- __Pyx_ReleaseBuffer((&__pyx_v_self->view));
-
- /* "View.MemoryView":377
- *
- * def __dealloc__(memoryview self):
- * if self.obj is not None: # <<<<<<<<<<<<<<
- * __Pyx_ReleaseBuffer(&self.view)
- * elif (<__pyx_buffer *> &self.view).obj == Py_None:
- */
- goto __pyx_L3;
- }
-
- /* "View.MemoryView":379
- * if self.obj is not None:
- * __Pyx_ReleaseBuffer(&self.view)
- * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<<
- *
- * (<__pyx_buffer *> &self.view).obj = NULL
- */
- __pyx_t_1 = (((Py_buffer *)(&__pyx_v_self->view))->obj == Py_None);
- if (__pyx_t_1) {
-
- /* "View.MemoryView":381
- * elif (<__pyx_buffer *> &self.view).obj == Py_None:
- *
- * (<__pyx_buffer *> &self.view).obj = NULL # <<<<<<<<<<<<<<
- * Py_DECREF(Py_None)
- *
- */
- ((Py_buffer *)(&__pyx_v_self->view))->obj = NULL;
-
- /* "View.MemoryView":382
- *
- * (<__pyx_buffer *> &self.view).obj = NULL
- * Py_DECREF(Py_None) # <<<<<<<<<<<<<<
- *
- * cdef int i
- */
- Py_DECREF(Py_None);
-
- /* "View.MemoryView":379
- * if self.obj is not None:
- * __Pyx_ReleaseBuffer(&self.view)
- * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<<
- *
- * (<__pyx_buffer *> &self.view).obj = NULL
- */
- }
- __pyx_L3:;
-
- /* "View.MemoryView":386
- * cdef int i
- * global __pyx_memoryview_thread_locks_used
- * if self.lock != NULL: # <<<<<<<<<<<<<<
- * for i in range(__pyx_memoryview_thread_locks_used):
- * if __pyx_memoryview_thread_locks[i] is self.lock:
- */
- __pyx_t_1 = (__pyx_v_self->lock != NULL);
- if (__pyx_t_1) {
-
- /* "View.MemoryView":387
- * global __pyx_memoryview_thread_locks_used
- * if self.lock != NULL:
- * for i in range(__pyx_memoryview_thread_locks_used): # <<<<<<<<<<<<<<
- * if __pyx_memoryview_thread_locks[i] is self.lock:
- * __pyx_memoryview_thread_locks_used -= 1
- */
- __pyx_t_2 = __pyx_memoryview_thread_locks_used;
- __pyx_t_3 = __pyx_t_2;
- for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
- __pyx_v_i = __pyx_t_4;
-
- /* "View.MemoryView":388
- * if self.lock != NULL:
- * for i in range(__pyx_memoryview_thread_locks_used):
- * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<<
- * __pyx_memoryview_thread_locks_used -= 1
- * if i != __pyx_memoryview_thread_locks_used:
- */
- __pyx_t_1 = ((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock);
- if (__pyx_t_1) {
-
- /* "View.MemoryView":389
- * for i in range(__pyx_memoryview_thread_locks_used):
- * if __pyx_memoryview_thread_locks[i] is self.lock:
- * __pyx_memoryview_thread_locks_used -= 1 # <<<<<<<<<<<<<<
- * if i != __pyx_memoryview_thread_locks_used:
- * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
- */
- __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used - 1);
-
- /* "View.MemoryView":390
- * if __pyx_memoryview_thread_locks[i] is self.lock:
- * __pyx_memoryview_thread_locks_used -= 1
- * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<<
- * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
- * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])
- */
- __pyx_t_1 = (__pyx_v_i != __pyx_memoryview_thread_locks_used);
- if (__pyx_t_1) {
-
- /* "View.MemoryView":392
- * if i != __pyx_memoryview_thread_locks_used:
- * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
- * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) # <<<<<<<<<<<<<<
- * break
- * else:
- */
- __pyx_t_5 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]);
- __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_v_i]);
-
- /* "View.MemoryView":391
- * __pyx_memoryview_thread_locks_used -= 1
- * if i != __pyx_memoryview_thread_locks_used:
- * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( # <<<<<<<<<<<<<<
- * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])
- * break
- */
- (__pyx_memoryview_thread_locks[__pyx_v_i]) = __pyx_t_5;
- (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_6;
-
- /* "View.MemoryView":390
- * if __pyx_memoryview_thread_locks[i] is self.lock:
- * __pyx_memoryview_thread_locks_used -= 1
- * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<<
- * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
- * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])
- */
- }
-
- /* "View.MemoryView":393
- * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
- * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])
- * break # <<<<<<<<<<<<<<
- * else:
- * PyThread_free_lock(self.lock)
- */
- goto __pyx_L6_break;
-
- /* "View.MemoryView":388
- * if self.lock != NULL:
- * for i in range(__pyx_memoryview_thread_locks_used):
- * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<<
- * __pyx_memoryview_thread_locks_used -= 1
- * if i != __pyx_memoryview_thread_locks_used:
- */
- }
- }
- /*else*/ {
-
- /* "View.MemoryView":395
- * break
- * else:
- * PyThread_free_lock(self.lock) # <<<<<<<<<<<<<<
- *
- * cdef char *get_item_pointer(memoryview self, object index) except NULL:
- */
- PyThread_free_lock(__pyx_v_self->lock);
- }
- __pyx_L6_break:;
-
- /* "View.MemoryView":386
- * cdef int i
- * global __pyx_memoryview_thread_locks_used
- * if self.lock != NULL: # <<<<<<<<<<<<<<
- * for i in range(__pyx_memoryview_thread_locks_used):
- * if __pyx_memoryview_thread_locks[i] is self.lock:
- */
- }
-
- /* "View.MemoryView":376
- * self.typeinfo = NULL
- *
- * def __dealloc__(memoryview self): # <<<<<<<<<<<<<<
- * if self.obj is not None:
- * __Pyx_ReleaseBuffer(&self.view)
- */
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
-}
-
-/* "View.MemoryView":397
- * PyThread_free_lock(self.lock)
- *
- * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<<
- * cdef Py_ssize_t dim
- * cdef char *itemp = self.view.buf
- */
-
-static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) {
- Py_ssize_t __pyx_v_dim;
- char *__pyx_v_itemp;
- PyObject *__pyx_v_idx = NULL;
- char *__pyx_r;
- __Pyx_RefNannyDeclarations
- Py_ssize_t __pyx_t_1;
- PyObject *__pyx_t_2 = NULL;
- Py_ssize_t __pyx_t_3;
- PyObject *(*__pyx_t_4)(PyObject *);
- PyObject *__pyx_t_5 = NULL;
- Py_ssize_t __pyx_t_6;
- char *__pyx_t_7;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("get_item_pointer", 0);
-
- /* "View.MemoryView":399
- * cdef char *get_item_pointer(memoryview self, object index) except NULL:
- * cdef Py_ssize_t dim
- * cdef char *itemp = self.view.buf # <<<<<<<<<<<<<<
- *
- * for dim, idx in enumerate(index):
- */
- __pyx_v_itemp = ((char *)__pyx_v_self->view.buf);
-
- /* "View.MemoryView":401
- * cdef char *itemp = self.view.buf
- *
- * for dim, idx in enumerate(index): # <<<<<<<<<<<<<<
- * itemp = pybuffer_index(&self.view, itemp, idx, dim)
- *
- */
- __pyx_t_1 = 0;
- if (likely(PyList_CheckExact(__pyx_v_index)) || PyTuple_CheckExact(__pyx_v_index)) {
- __pyx_t_2 = __pyx_v_index; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0;
- __pyx_t_4 = NULL;
- } else {
- __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 401, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_2);
- __pyx_t_4 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 401, __pyx_L1_error)
- }
- for (;;) {
- if (likely(!__pyx_t_4)) {
- if (likely(PyList_CheckExact(__pyx_t_2))) {
- if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break;
- #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
- __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(1, 401, __pyx_L1_error)
- #else
- __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 401, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_5);
- #endif
- } else {
- if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
- #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
- __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(1, 401, __pyx_L1_error)
- #else
- __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 401, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_5);
- #endif
- }
- } else {
- __pyx_t_5 = __pyx_t_4(__pyx_t_2);
- if (unlikely(!__pyx_t_5)) {
- PyObject* exc_type = PyErr_Occurred();
- if (exc_type) {
- if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else __PYX_ERR(1, 401, __pyx_L1_error)
- }
- break;
- }
- __Pyx_GOTREF(__pyx_t_5);
- }
- __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_5);
- __pyx_t_5 = 0;
- __pyx_v_dim = __pyx_t_1;
- __pyx_t_1 = (__pyx_t_1 + 1);
-
- /* "View.MemoryView":402
- *
- * for dim, idx in enumerate(index):
- * itemp = pybuffer_index(&self.view, itemp, idx, dim) # <<<<<<<<<<<<<<
- *
- * return itemp
- */
- __pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 402, __pyx_L1_error)
- __pyx_t_7 = __pyx_pybuffer_index((&__pyx_v_self->view), __pyx_v_itemp, __pyx_t_6, __pyx_v_dim); if (unlikely(__pyx_t_7 == ((char *)NULL))) __PYX_ERR(1, 402, __pyx_L1_error)
- __pyx_v_itemp = __pyx_t_7;
-
- /* "View.MemoryView":401
- * cdef char *itemp = self.view.buf
- *
- * for dim, idx in enumerate(index): # <<<<<<<<<<<<<<
- * itemp = pybuffer_index(&self.view, itemp, idx, dim)
- *
- */
- }
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
- /* "View.MemoryView":404
- * itemp = pybuffer_index(&self.view, itemp, idx, dim)
- *
- * return itemp # <<<<<<<<<<<<<<
- *
- *
- */
- __pyx_r = __pyx_v_itemp;
- goto __pyx_L0;
-
- /* "View.MemoryView":397
- * PyThread_free_lock(self.lock)
- *
- * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<<
- * cdef Py_ssize_t dim
- * cdef char *itemp = self.view.buf
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_2);
- __Pyx_XDECREF(__pyx_t_5);
- __Pyx_AddTraceback("View.MemoryView.memoryview.get_item_pointer", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = NULL;
- __pyx_L0:;
- __Pyx_XDECREF(__pyx_v_idx);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":407
- *
- *
- * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<<
- * if index is Ellipsis:
- * return self
- */
-
-/* Python wrapper */
-static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index); /*proto*/
-static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- PyObject *__pyx_r = 0;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0);
- __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) {
- PyObject *__pyx_v_have_slices = NULL;
- PyObject *__pyx_v_indices = NULL;
- char *__pyx_v_itemp;
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- int __pyx_t_1;
- PyObject *__pyx_t_2 = NULL;
- PyObject *__pyx_t_3 = NULL;
- PyObject *__pyx_t_4 = NULL;
- char *__pyx_t_5;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("__getitem__", 0);
-
- /* "View.MemoryView":408
- *
- * def __getitem__(memoryview self, object index):
- * if index is Ellipsis: # <<<<<<<<<<<<<<
- * return self
- *
- */
- __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis);
- if (__pyx_t_1) {
-
- /* "View.MemoryView":409
- * def __getitem__(memoryview self, object index):
- * if index is Ellipsis:
- * return self # <<<<<<<<<<<<<<
- *
- * have_slices, indices = _unellipsify(index, self.view.ndim)
- */
- __Pyx_XDECREF(__pyx_r);
- __Pyx_INCREF((PyObject *)__pyx_v_self);
- __pyx_r = ((PyObject *)__pyx_v_self);
- goto __pyx_L0;
-
- /* "View.MemoryView":408
- *
- * def __getitem__(memoryview self, object index):
- * if index is Ellipsis: # <<<<<<<<<<<<<<
- * return self
- *
- */
- }
-
- /* "View.MemoryView":411
- * return self
- *
- * have_slices, indices = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<<
- *
- * cdef char *itemp
- */
- __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 411, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_2);
- if (likely(__pyx_t_2 != Py_None)) {
- PyObject* sequence = __pyx_t_2;
- Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
- if (unlikely(size != 2)) {
- if (size > 2) __Pyx_RaiseTooManyValuesError(2);
- else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- __PYX_ERR(1, 411, __pyx_L1_error)
- }
- #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
- __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0);
- __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1);
- __Pyx_INCREF(__pyx_t_3);
- __Pyx_INCREF(__pyx_t_4);
- #else
- __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 411, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 411, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_4);
- #endif
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- } else {
- __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 411, __pyx_L1_error)
- }
- __pyx_v_have_slices = __pyx_t_3;
- __pyx_t_3 = 0;
- __pyx_v_indices = __pyx_t_4;
- __pyx_t_4 = 0;
-
- /* "View.MemoryView":414
- *
- * cdef char *itemp
- * if have_slices: # <<<<<<<<<<<<<<
- * return memview_slice(self, indices)
- * else:
- */
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 414, __pyx_L1_error)
- if (__pyx_t_1) {
-
- /* "View.MemoryView":415
- * cdef char *itemp
- * if have_slices:
- * return memview_slice(self, indices) # <<<<<<<<<<<<<<
- * else:
- * itemp = self.get_item_pointer(indices)
- */
- __Pyx_XDECREF(__pyx_r);
- __pyx_t_2 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 415, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_2);
- __pyx_r = __pyx_t_2;
- __pyx_t_2 = 0;
- goto __pyx_L0;
-
- /* "View.MemoryView":414
- *
- * cdef char *itemp
- * if have_slices: # <<<<<<<<<<<<<<
- * return memview_slice(self, indices)
- * else:
- */
- }
-
- /* "View.MemoryView":417
- * return memview_slice(self, indices)
- * else:
- * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<<
- * return self.convert_item_to_object(itemp)
- *
- */
- /*else*/ {
- __pyx_t_5 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_5 == ((char *)NULL))) __PYX_ERR(1, 417, __pyx_L1_error)
- __pyx_v_itemp = __pyx_t_5;
-
- /* "View.MemoryView":418
- * else:
- * itemp = self.get_item_pointer(indices)
- * return self.convert_item_to_object(itemp) # <<<<<<<<<<<<<<
- *
- * def __setitem__(memoryview self, object index, object value):
- */
- __Pyx_XDECREF(__pyx_r);
- __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 418, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_2);
- __pyx_r = __pyx_t_2;
- __pyx_t_2 = 0;
- goto __pyx_L0;
- }
-
- /* "View.MemoryView":407
- *
- *
- * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<<
- * if index is Ellipsis:
- * return self
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_2);
- __Pyx_XDECREF(__pyx_t_3);
- __Pyx_XDECREF(__pyx_t_4);
- __Pyx_AddTraceback("View.MemoryView.memoryview.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = NULL;
- __pyx_L0:;
- __Pyx_XDECREF(__pyx_v_have_slices);
- __Pyx_XDECREF(__pyx_v_indices);
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":420
- * return self.convert_item_to_object(itemp)
- *
- * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<<
- * if self.view.readonly:
- * raise TypeError, "Cannot assign to read-only memoryview"
- */
-
-/* Python wrapper */
-static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /*proto*/
-static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- int __pyx_r;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0);
- __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index), ((PyObject *)__pyx_v_value));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) {
- PyObject *__pyx_v_have_slices = NULL;
- PyObject *__pyx_v_obj = NULL;
- int __pyx_r;
- __Pyx_RefNannyDeclarations
- PyObject *__pyx_t_1 = NULL;
- PyObject *__pyx_t_2 = NULL;
- PyObject *__pyx_t_3 = NULL;
- int __pyx_t_4;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("__setitem__", 0);
- __Pyx_INCREF(__pyx_v_index);
-
- /* "View.MemoryView":421
- *
- * def __setitem__(memoryview self, object index, object value):
- * if self.view.readonly: # <<<<<<<<<<<<<<
- * raise TypeError, "Cannot assign to read-only memoryview"
- *
- */
- if (unlikely(__pyx_v_self->view.readonly)) {
-
- /* "View.MemoryView":422
- * def __setitem__(memoryview self, object index, object value):
- * if self.view.readonly:
- * raise TypeError, "Cannot assign to read-only memoryview" # <<<<<<<<<<<<<<
- *
- * have_slices, index = _unellipsify(index, self.view.ndim)
- */
- __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_Cannot_assign_to_read_only_memor, 0, 0);
- __PYX_ERR(1, 422, __pyx_L1_error)
-
- /* "View.MemoryView":421
- *
- * def __setitem__(memoryview self, object index, object value):
- * if self.view.readonly: # <<<<<<<<<<<<<<
- * raise TypeError, "Cannot assign to read-only memoryview"
- *
- */
- }
-
- /* "View.MemoryView":424
- * raise TypeError, "Cannot assign to read-only memoryview"
- *
- * have_slices, index = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<<
- *
- * if have_slices:
- */
- __pyx_t_1 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 424, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- if (likely(__pyx_t_1 != Py_None)) {
- PyObject* sequence = __pyx_t_1;
- Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
- if (unlikely(size != 2)) {
- if (size > 2) __Pyx_RaiseTooManyValuesError(2);
- else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- __PYX_ERR(1, 424, __pyx_L1_error)
- }
- #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
- __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0);
- __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1);
- __Pyx_INCREF(__pyx_t_2);
- __Pyx_INCREF(__pyx_t_3);
- #else
- __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 424, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 424, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_3);
- #endif
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- } else {
- __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 424, __pyx_L1_error)
- }
- __pyx_v_have_slices = __pyx_t_2;
- __pyx_t_2 = 0;
- __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_3);
- __pyx_t_3 = 0;
-
- /* "View.MemoryView":426
- * have_slices, index = _unellipsify(index, self.view.ndim)
- *
- * if have_slices: # <<<<<<<<<<<<<<
- * obj = self.is_slice(value)
- * if obj:
- */
- __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(1, 426, __pyx_L1_error)
- if (__pyx_t_4) {
-
- /* "View.MemoryView":427
- *
- * if have_slices:
- * obj = self.is_slice(value) # <<<<<<<<<<<<<<
- * if obj:
- * self.setitem_slice_assignment(self[index], obj)
- */
- __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 427, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_v_obj = __pyx_t_1;
- __pyx_t_1 = 0;
-
- /* "View.MemoryView":428
- * if have_slices:
- * obj = self.is_slice(value)
- * if obj: # <<<<<<<<<<<<<<
- * self.setitem_slice_assignment(self[index], obj)
- * else:
- */
- __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_obj); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(1, 428, __pyx_L1_error)
- if (__pyx_t_4) {
-
- /* "View.MemoryView":429
- * obj = self.is_slice(value)
- * if obj:
- * self.setitem_slice_assignment(self[index], obj) # <<<<<<<<<<<<<<
- * else:
- * self.setitem_slice_assign_scalar(self[index], value)
- */
- __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 429, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_1, __pyx_v_obj); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 429, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_3);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
- /* "View.MemoryView":428
- * if have_slices:
- * obj = self.is_slice(value)
- * if obj: # <<<<<<<<<<<<<<
- * self.setitem_slice_assignment(self[index], obj)
- * else:
- */
- goto __pyx_L5;
- }
-
- /* "View.MemoryView":431
- * self.setitem_slice_assignment(self[index], obj)
- * else:
- * self.setitem_slice_assign_scalar(self[index], value) # <<<<<<<<<<<<<<
- * else:
- * self.setitem_indexed(index, value)
- */
- /*else*/ {
- __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 431, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_3);
- if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(1, 431, __pyx_L1_error)
- __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_3), __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 431, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- }
- __pyx_L5:;
-
- /* "View.MemoryView":426
- * have_slices, index = _unellipsify(index, self.view.ndim)
- *
- * if have_slices: # <<<<<<<<<<<<<<
- * obj = self.is_slice(value)
- * if obj:
- */
- goto __pyx_L4;
- }
-
- /* "View.MemoryView":433
- * self.setitem_slice_assign_scalar(self[index], value)
- * else:
- * self.setitem_indexed(index, value) # <<<<<<<<<<<<<<
- *
- * cdef is_slice(self, obj):
- */
- /*else*/ {
- __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 433, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- }
- __pyx_L4:;
-
- /* "View.MemoryView":420
- * return self.convert_item_to_object(itemp)
- *
- * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<<
- * if self.view.readonly:
- * raise TypeError, "Cannot assign to read-only memoryview"
- */
-
- /* function exit code */
- __pyx_r = 0;
- goto __pyx_L0;
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_1);
- __Pyx_XDECREF(__pyx_t_2);
- __Pyx_XDECREF(__pyx_t_3);
- __Pyx_AddTraceback("View.MemoryView.memoryview.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = -1;
- __pyx_L0:;
- __Pyx_XDECREF(__pyx_v_have_slices);
- __Pyx_XDECREF(__pyx_v_obj);
- __Pyx_XDECREF(__pyx_v_index);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":435
- * self.setitem_indexed(index, value)
- *
- * cdef is_slice(self, obj): # <<<<<<<<<<<<<<
- * if not isinstance(obj, memoryview):
- * try:
- */
-
-static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj) {
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- int __pyx_t_1;
- int __pyx_t_2;
- PyObject *__pyx_t_3 = NULL;
- PyObject *__pyx_t_4 = NULL;
- PyObject *__pyx_t_5 = NULL;
- PyObject *__pyx_t_6 = NULL;
- PyObject *__pyx_t_7 = NULL;
- PyObject *__pyx_t_8 = NULL;
- int __pyx_t_9;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("is_slice", 0);
- __Pyx_INCREF(__pyx_v_obj);
-
- /* "View.MemoryView":436
- *
- * cdef is_slice(self, obj):
- * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<<
- * try:
- * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
- */
- __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_obj, __pyx_memoryview_type);
- __pyx_t_2 = (!__pyx_t_1);
- if (__pyx_t_2) {
-
- /* "View.MemoryView":437
- * cdef is_slice(self, obj):
- * if not isinstance(obj, memoryview):
- * try: # <<<<<<<<<<<<<<
- * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
- * self.dtype_is_object)
- */
- {
- __Pyx_PyThreadState_declare
- __Pyx_PyThreadState_assign
- __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5);
- __Pyx_XGOTREF(__pyx_t_3);
- __Pyx_XGOTREF(__pyx_t_4);
- __Pyx_XGOTREF(__pyx_t_5);
- /*try:*/ {
-
- /* "View.MemoryView":438
- * if not isinstance(obj, memoryview):
- * try:
- * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<<
- * self.dtype_is_object)
- * except TypeError:
- */
- __pyx_t_6 = __Pyx_PyInt_From_int(((__pyx_v_self->flags & (~PyBUF_WRITABLE)) | PyBUF_ANY_CONTIGUOUS)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 438, __pyx_L4_error)
- __Pyx_GOTREF(__pyx_t_6);
-
- /* "View.MemoryView":439
- * try:
- * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
- * self.dtype_is_object) # <<<<<<<<<<<<<<
- * except TypeError:
- * return None
- */
- __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 439, __pyx_L4_error)
- __Pyx_GOTREF(__pyx_t_7);
-
- /* "View.MemoryView":438
- * if not isinstance(obj, memoryview):
- * try:
- * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<<
- * self.dtype_is_object)
- * except TypeError:
- */
- __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 438, __pyx_L4_error)
- __Pyx_GOTREF(__pyx_t_8);
- __Pyx_INCREF(__pyx_v_obj);
- __Pyx_GIVEREF(__pyx_v_obj);
- PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_obj);
- __Pyx_GIVEREF(__pyx_t_6);
- PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6);
- __Pyx_GIVEREF(__pyx_t_7);
- PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7);
- __pyx_t_6 = 0;
- __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 438, __pyx_L4_error)
- __Pyx_GOTREF(__pyx_t_7);
- __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- __Pyx_DECREF_SET(__pyx_v_obj, __pyx_t_7);
- __pyx_t_7 = 0;
-
- /* "View.MemoryView":437
- * cdef is_slice(self, obj):
- * if not isinstance(obj, memoryview):
- * try: # <<<<<<<<<<<<<<
- * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
- * self.dtype_is_object)
- */
- }
- __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
- __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
- __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
- goto __pyx_L9_try_end;
- __pyx_L4_error:;
- __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
- __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
- __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
-
- /* "View.MemoryView":440
- * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
- * self.dtype_is_object)
- * except TypeError: # <<<<<<<<<<<<<<
- * return None
- *
- */
- __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError);
- if (__pyx_t_9) {
- __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_6) < 0) __PYX_ERR(1, 440, __pyx_L6_except_error)
- __Pyx_XGOTREF(__pyx_t_7);
- __Pyx_XGOTREF(__pyx_t_8);
- __Pyx_XGOTREF(__pyx_t_6);
-
- /* "View.MemoryView":441
- * self.dtype_is_object)
- * except TypeError:
- * return None # <<<<<<<<<<<<<<
- *
- * return obj
- */
- __Pyx_XDECREF(__pyx_r);
- __pyx_r = Py_None; __Pyx_INCREF(Py_None);
- __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- goto __pyx_L7_except_return;
- }
- goto __pyx_L6_except_error;
-
- /* "View.MemoryView":437
- * cdef is_slice(self, obj):
- * if not isinstance(obj, memoryview):
- * try: # <<<<<<<<<<<<<<
- * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
- * self.dtype_is_object)
- */
- __pyx_L6_except_error:;
- __Pyx_XGIVEREF(__pyx_t_3);
- __Pyx_XGIVEREF(__pyx_t_4);
- __Pyx_XGIVEREF(__pyx_t_5);
- __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5);
- goto __pyx_L1_error;
- __pyx_L7_except_return:;
- __Pyx_XGIVEREF(__pyx_t_3);
- __Pyx_XGIVEREF(__pyx_t_4);
- __Pyx_XGIVEREF(__pyx_t_5);
- __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5);
- goto __pyx_L0;
- __pyx_L9_try_end:;
- }
-
- /* "View.MemoryView":436
- *
- * cdef is_slice(self, obj):
- * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<<
- * try:
- * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
- */
- }
-
- /* "View.MemoryView":443
- * return None
- *
- * return obj # <<<<<<<<<<<<<<
- *
- * cdef setitem_slice_assignment(self, dst, src):
- */
- __Pyx_XDECREF(__pyx_r);
- __Pyx_INCREF(__pyx_v_obj);
- __pyx_r = __pyx_v_obj;
- goto __pyx_L0;
-
- /* "View.MemoryView":435
- * self.setitem_indexed(index, value)
- *
- * cdef is_slice(self, obj): # <<<<<<<<<<<<<<
- * if not isinstance(obj, memoryview):
- * try:
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_6);
- __Pyx_XDECREF(__pyx_t_7);
- __Pyx_XDECREF(__pyx_t_8);
- __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = 0;
- __pyx_L0:;
- __Pyx_XDECREF(__pyx_v_obj);
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":445
- * return obj
- *
- * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<<
- * cdef __Pyx_memviewslice dst_slice
- * cdef __Pyx_memviewslice src_slice
- */
-
-static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src) {
- __Pyx_memviewslice __pyx_v_dst_slice;
- __Pyx_memviewslice __pyx_v_src_slice;
- __Pyx_memviewslice __pyx_v_msrc;
- __Pyx_memviewslice __pyx_v_mdst;
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- __Pyx_memviewslice *__pyx_t_1;
- PyObject *__pyx_t_2 = NULL;
- int __pyx_t_3;
- int __pyx_t_4;
- int __pyx_t_5;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("setitem_slice_assignment", 0);
-
- /* "View.MemoryView":448
- * cdef __Pyx_memviewslice dst_slice
- * cdef __Pyx_memviewslice src_slice
- * cdef __Pyx_memviewslice msrc = get_slice_from_memview(src, &src_slice)[0] # <<<<<<<<<<<<<<
- * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0]
- *
- */
- if (!(likely(((__pyx_v_src) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_src, __pyx_memoryview_type))))) __PYX_ERR(1, 448, __pyx_L1_error)
- __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_src), (&__pyx_v_src_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 448, __pyx_L1_error)
- __pyx_v_msrc = (__pyx_t_1[0]);
-
- /* "View.MemoryView":449
- * cdef __Pyx_memviewslice src_slice
- * cdef __Pyx_memviewslice msrc = get_slice_from_memview(src, &src_slice)[0]
- * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] # <<<<<<<<<<<<<<
- *
- * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object)
- */
- if (!(likely(((__pyx_v_dst) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_dst, __pyx_memoryview_type))))) __PYX_ERR(1, 449, __pyx_L1_error)
- __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 449, __pyx_L1_error)
- __pyx_v_mdst = (__pyx_t_1[0]);
-
- /* "View.MemoryView":451
- * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0]
- *
- * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) # <<<<<<<<<<<<<<
- *
- * cdef setitem_slice_assign_scalar(self, memoryview dst, value):
- */
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 451, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 451, __pyx_L1_error)
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 451, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_2);
- __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 451, __pyx_L1_error)
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_5 = __pyx_memoryview_copy_contents(__pyx_v_msrc, __pyx_v_mdst, __pyx_t_3, __pyx_t_4, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 451, __pyx_L1_error)
-
- /* "View.MemoryView":445
- * return obj
- *
- * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<<
- * cdef __Pyx_memviewslice dst_slice
- * cdef __Pyx_memviewslice src_slice
- */
-
- /* function exit code */
- __pyx_r = Py_None; __Pyx_INCREF(Py_None);
- goto __pyx_L0;
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_2);
- __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assignment", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = 0;
- __pyx_L0:;
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":453
- * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object)
- *
- * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<<
- * cdef int array[128]
- * cdef void *tmp = NULL
- */
-
-static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value) {
- int __pyx_v_array[0x80];
- void *__pyx_v_tmp;
- void *__pyx_v_item;
- __Pyx_memviewslice *__pyx_v_dst_slice;
- __Pyx_memviewslice __pyx_v_tmp_slice;
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- __Pyx_memviewslice *__pyx_t_1;
- int __pyx_t_2;
- PyObject *__pyx_t_3 = NULL;
- int __pyx_t_4;
- int __pyx_t_5;
- char const *__pyx_t_6;
- PyObject *__pyx_t_7 = NULL;
- PyObject *__pyx_t_8 = NULL;
- PyObject *__pyx_t_9 = NULL;
- PyObject *__pyx_t_10 = NULL;
- PyObject *__pyx_t_11 = NULL;
- PyObject *__pyx_t_12 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("setitem_slice_assign_scalar", 0);
-
- /* "View.MemoryView":455
- * cdef setitem_slice_assign_scalar(self, memoryview dst, value):
- * cdef int array[128]
- * cdef void *tmp = NULL # <<<<<<<<<<<<<<
- * cdef void *item
- *
- */
- __pyx_v_tmp = NULL;
-
- /* "View.MemoryView":460
- * cdef __Pyx_memviewslice *dst_slice
- * cdef __Pyx_memviewslice tmp_slice
- * dst_slice = get_slice_from_memview(dst, &tmp_slice) # <<<<<<<<<<<<<<
- *
- * if self.view.itemsize > sizeof(array):
- */
- __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_dst, (&__pyx_v_tmp_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 460, __pyx_L1_error)
- __pyx_v_dst_slice = __pyx_t_1;
-
- /* "View.MemoryView":462
- * dst_slice = get_slice_from_memview(dst, &tmp_slice)
- *
- * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<<
- * tmp = PyMem_Malloc(self.view.itemsize)
- * if tmp == NULL:
- */
- __pyx_t_2 = (((size_t)__pyx_v_self->view.itemsize) > (sizeof(__pyx_v_array)));
- if (__pyx_t_2) {
-
- /* "View.MemoryView":463
- *
- * if self.view.itemsize > sizeof(array):
- * tmp = PyMem_Malloc(self.view.itemsize) # <<<<<<<<<<<<<<
- * if tmp == NULL:
- * raise MemoryError
- */
- __pyx_v_tmp = PyMem_Malloc(__pyx_v_self->view.itemsize);
-
- /* "View.MemoryView":464
- * if self.view.itemsize > sizeof(array):
- * tmp = PyMem_Malloc(self.view.itemsize)
- * if tmp == NULL: # <<<<<<<<<<<<<<
- * raise MemoryError
- * item = tmp
- */
- __pyx_t_2 = (__pyx_v_tmp == NULL);
- if (unlikely(__pyx_t_2)) {
-
- /* "View.MemoryView":465
- * tmp = PyMem_Malloc(self.view.itemsize)
- * if tmp == NULL:
- * raise MemoryError # <<<<<<<<<<<<<<
- * item = tmp
- * else:
- */
- PyErr_NoMemory(); __PYX_ERR(1, 465, __pyx_L1_error)
-
- /* "View.MemoryView":464
- * if self.view.itemsize > sizeof(array):
- * tmp = PyMem_Malloc(self.view.itemsize)
- * if tmp == NULL: # <<<<<<<<<<<<<<
- * raise MemoryError
- * item = tmp
- */
- }
-
- /* "View.MemoryView":466
- * if tmp == NULL:
- * raise MemoryError
- * item = tmp # <<<<<<<<<<<<<<
- * else:
- * item = array
- */
- __pyx_v_item = __pyx_v_tmp;
-
- /* "View.MemoryView":462
- * dst_slice = get_slice_from_memview(dst, &tmp_slice)
- *
- * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<<
- * tmp = PyMem_Malloc(self.view.itemsize)
- * if tmp == NULL:
- */
- goto __pyx_L3;
- }
-
- /* "View.MemoryView":468
- * item = tmp
- * else:
- * item = array # <<<<<<<<<<<<<<
- *
- * try:
- */
- /*else*/ {
- __pyx_v_item = ((void *)__pyx_v_array);
- }
- __pyx_L3:;
-
- /* "View.MemoryView":470
- * item = array
- *
- * try: # <<<<<<<<<<<<<<
- * if self.dtype_is_object:
- * ( item)[0] = value
- */
- /*try:*/ {
-
- /* "View.MemoryView":471
- *
- * try:
- * if self.dtype_is_object: # <<<<<<<<<<<<<<
- * ( item)[0] = value
- * else:
- */
- if (__pyx_v_self->dtype_is_object) {
-
- /* "View.MemoryView":472
- * try:
- * if self.dtype_is_object:
- * ( item)[0] = value # <<<<<<<<<<<<<<
- * else:
- * self.assign_item_from_object( item, value)
- */
- (((PyObject **)__pyx_v_item)[0]) = ((PyObject *)__pyx_v_value);
-
- /* "View.MemoryView":471
- *
- * try:
- * if self.dtype_is_object: # <<<<<<<<<<<<<<
- * ( item)[0] = value
- * else:
- */
- goto __pyx_L8;
- }
-
- /* "View.MemoryView":474
- * ( item)[0] = value
- * else:
- * self.assign_item_from_object( item, value) # <<<<<<<<<<<<<<
- *
- *
- */
- /*else*/ {
- __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, ((char *)__pyx_v_item), __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 474, __pyx_L6_error)
- __Pyx_GOTREF(__pyx_t_3);
- __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- }
- __pyx_L8:;
-
- /* "View.MemoryView":478
- *
- *
- * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<<
- * assert_direct_dimensions(self.view.suboffsets, self.view.ndim)
- * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize,
- */
- __pyx_t_2 = (__pyx_v_self->view.suboffsets != NULL);
- if (__pyx_t_2) {
-
- /* "View.MemoryView":479
- *
- * if self.view.suboffsets != NULL:
- * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) # <<<<<<<<<<<<<<
- * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize,
- * item, self.dtype_is_object)
- */
- __pyx_t_4 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 479, __pyx_L6_error)
-
- /* "View.MemoryView":478
- *
- *
- * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<<
- * assert_direct_dimensions(self.view.suboffsets, self.view.ndim)
- * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize,
- */
- }
-
- /* "View.MemoryView":480
- * if self.view.suboffsets != NULL:
- * assert_direct_dimensions(self.view.suboffsets, self.view.ndim)
- * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, # <<<<<<<<<<<<<<
- * item, self.dtype_is_object)
- * finally:
- */
- __pyx_memoryview_slice_assign_scalar(__pyx_v_dst_slice, __pyx_v_dst->view.ndim, __pyx_v_self->view.itemsize, __pyx_v_item, __pyx_v_self->dtype_is_object);
- }
-
- /* "View.MemoryView":483
- * item, self.dtype_is_object)
- * finally:
- * PyMem_Free(tmp) # <<<<<<<<<<<<<<
- *
- * cdef setitem_indexed(self, index, value):
- */
- /*finally:*/ {
- /*normal exit:*/{
- PyMem_Free(__pyx_v_tmp);
- goto __pyx_L7;
- }
- __pyx_L6_error:;
- /*exception exit:*/{
- __Pyx_PyThreadState_declare
- __Pyx_PyThreadState_assign
- __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0;
- __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
- if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12);
- if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9);
- __Pyx_XGOTREF(__pyx_t_7);
- __Pyx_XGOTREF(__pyx_t_8);
- __Pyx_XGOTREF(__pyx_t_9);
- __Pyx_XGOTREF(__pyx_t_10);
- __Pyx_XGOTREF(__pyx_t_11);
- __Pyx_XGOTREF(__pyx_t_12);
- __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename;
- {
- PyMem_Free(__pyx_v_tmp);
- }
- if (PY_MAJOR_VERSION >= 3) {
- __Pyx_XGIVEREF(__pyx_t_10);
- __Pyx_XGIVEREF(__pyx_t_11);
- __Pyx_XGIVEREF(__pyx_t_12);
- __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
- }
- __Pyx_XGIVEREF(__pyx_t_7);
- __Pyx_XGIVEREF(__pyx_t_8);
- __Pyx_XGIVEREF(__pyx_t_9);
- __Pyx_ErrRestore(__pyx_t_7, __pyx_t_8, __pyx_t_9);
- __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0;
- __pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_5; __pyx_filename = __pyx_t_6;
- goto __pyx_L1_error;
- }
- __pyx_L7:;
- }
-
- /* "View.MemoryView":453
- * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object)
- *
- * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<<
- * cdef int array[128]
- * cdef void *tmp = NULL
- */
-
- /* function exit code */
- __pyx_r = Py_None; __Pyx_INCREF(Py_None);
- goto __pyx_L0;
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_3);
- __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assign_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = 0;
- __pyx_L0:;
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":485
- * PyMem_Free(tmp)
- *
- * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<<
- * cdef char *itemp = self.get_item_pointer(index)
- * self.assign_item_from_object(itemp, value)
- */
-
-static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) {
- char *__pyx_v_itemp;
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- char *__pyx_t_1;
- PyObject *__pyx_t_2 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("setitem_indexed", 0);
-
- /* "View.MemoryView":486
- *
- * cdef setitem_indexed(self, index, value):
- * cdef char *itemp = self.get_item_pointer(index) # <<<<<<<<<<<<<<
- * self.assign_item_from_object(itemp, value)
- *
- */
- __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_index); if (unlikely(__pyx_t_1 == ((char *)NULL))) __PYX_ERR(1, 486, __pyx_L1_error)
- __pyx_v_itemp = __pyx_t_1;
-
- /* "View.MemoryView":487
- * cdef setitem_indexed(self, index, value):
- * cdef char *itemp = self.get_item_pointer(index)
- * self.assign_item_from_object(itemp, value) # <<<<<<<<<<<<<<
- *
- * cdef convert_item_to_object(self, char *itemp):
- */
- __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 487, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_2);
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
- /* "View.MemoryView":485
- * PyMem_Free(tmp)
- *
- * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<<
- * cdef char *itemp = self.get_item_pointer(index)
- * self.assign_item_from_object(itemp, value)
- */
-
- /* function exit code */
- __pyx_r = Py_None; __Pyx_INCREF(Py_None);
- goto __pyx_L0;
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_2);
- __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_indexed", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = 0;
- __pyx_L0:;
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":489
- * self.assign_item_from_object(itemp, value)
- *
- * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<<
- * """Only used if instantiated manually by the user, or if Cython doesn't
- * know how to convert the type"""
- */
-
-static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp) {
- PyObject *__pyx_v_struct = NULL;
- PyObject *__pyx_v_bytesitem = 0;
- PyObject *__pyx_v_result = NULL;
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- PyObject *__pyx_t_1 = NULL;
- PyObject *__pyx_t_2 = NULL;
- PyObject *__pyx_t_3 = NULL;
- PyObject *__pyx_t_4 = NULL;
- PyObject *__pyx_t_5 = NULL;
- PyObject *__pyx_t_6 = NULL;
- PyObject *__pyx_t_7 = NULL;
- int __pyx_t_8;
- Py_ssize_t __pyx_t_9;
- int __pyx_t_10;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("convert_item_to_object", 0);
-
- /* "View.MemoryView":492
- * """Only used if instantiated manually by the user, or if Cython doesn't
- * know how to convert the type"""
- * import struct # <<<<<<<<<<<<<<
- * cdef bytes bytesitem
- *
- */
- __pyx_t_1 = __Pyx_ImportDottedModule(__pyx_n_s_struct, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 492, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_v_struct = __pyx_t_1;
- __pyx_t_1 = 0;
-
- /* "View.MemoryView":495
- * cdef bytes bytesitem
- *
- * bytesitem = itemp[:self.view.itemsize] # <<<<<<<<<<<<<<
- * try:
- * result = struct.unpack(self.view.format, bytesitem)
- */
- __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_itemp + 0, __pyx_v_self->view.itemsize - 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_v_bytesitem = ((PyObject*)__pyx_t_1);
- __pyx_t_1 = 0;
-
- /* "View.MemoryView":496
- *
- * bytesitem = itemp[:self.view.itemsize]
- * try: # <<<<<<<<<<<<<<
- * result = struct.unpack(self.view.format, bytesitem)
- * except struct.error:
- */
- {
- __Pyx_PyThreadState_declare
- __Pyx_PyThreadState_assign
- __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
- __Pyx_XGOTREF(__pyx_t_2);
- __Pyx_XGOTREF(__pyx_t_3);
- __Pyx_XGOTREF(__pyx_t_4);
- /*try:*/ {
-
- /* "View.MemoryView":497
- * bytesitem = itemp[:self.view.itemsize]
- * try:
- * result = struct.unpack(self.view.format, bytesitem) # <<<<<<<<<<<<<<
- * except struct.error:
- * raise ValueError, "Unable to convert item to object"
- */
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_unpack); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 497, __pyx_L3_error)
- __Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 497, __pyx_L3_error)
- __Pyx_GOTREF(__pyx_t_6);
- __pyx_t_7 = NULL;
- __pyx_t_8 = 0;
- if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
- __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
- if (likely(__pyx_t_7)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
- __Pyx_INCREF(__pyx_t_7);
- __Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_5, function);
- __pyx_t_8 = 1;
- }
- }
- {
- PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem};
- __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_8, 2+__pyx_t_8);
- __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
- __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 497, __pyx_L3_error)
- __Pyx_GOTREF(__pyx_t_1);
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- }
- __pyx_v_result = __pyx_t_1;
- __pyx_t_1 = 0;
-
- /* "View.MemoryView":496
- *
- * bytesitem = itemp[:self.view.itemsize]
- * try: # <<<<<<<<<<<<<<
- * result = struct.unpack(self.view.format, bytesitem)
- * except struct.error:
- */
- }
-
- /* "View.MemoryView":501
- * raise ValueError, "Unable to convert item to object"
- * else:
- * if len(self.view.format) == 1: # <<<<<<<<<<<<<<
- * return result[0]
- * return result
- */
- /*else:*/ {
- __pyx_t_9 = __Pyx_ssize_strlen(__pyx_v_self->view.format); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(1, 501, __pyx_L5_except_error)
- __pyx_t_10 = (__pyx_t_9 == 1);
- if (__pyx_t_10) {
-
- /* "View.MemoryView":502
- * else:
- * if len(self.view.format) == 1:
- * return result[0] # <<<<<<<<<<<<<<
- * return result
- *
- */
- __Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_result, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 502, __pyx_L5_except_error)
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_r = __pyx_t_1;
- __pyx_t_1 = 0;
- goto __pyx_L6_except_return;
-
- /* "View.MemoryView":501
- * raise ValueError, "Unable to convert item to object"
- * else:
- * if len(self.view.format) == 1: # <<<<<<<<<<<<<<
- * return result[0]
- * return result
- */
- }
-
- /* "View.MemoryView":503
- * if len(self.view.format) == 1:
- * return result[0]
- * return result # <<<<<<<<<<<<<<
- *
- * cdef assign_item_from_object(self, char *itemp, object value):
- */
- __Pyx_XDECREF(__pyx_r);
- __Pyx_INCREF(__pyx_v_result);
- __pyx_r = __pyx_v_result;
- goto __pyx_L6_except_return;
- }
- __pyx_L3_error:;
- __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
- __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
- __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
- __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-
- /* "View.MemoryView":498
- * try:
- * result = struct.unpack(self.view.format, bytesitem)
- * except struct.error: # <<<<<<<<<<<<<<
- * raise ValueError, "Unable to convert item to object"
- * else:
- */
- __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_5, &__pyx_t_6);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 498, __pyx_L5_except_error)
- __Pyx_GOTREF(__pyx_t_7);
- __pyx_t_8 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_7);
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __Pyx_ErrRestore(__pyx_t_1, __pyx_t_5, __pyx_t_6);
- __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_6 = 0;
- if (__pyx_t_8) {
- __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(1, 498, __pyx_L5_except_error)
- __Pyx_XGOTREF(__pyx_t_6);
- __Pyx_XGOTREF(__pyx_t_5);
- __Pyx_XGOTREF(__pyx_t_1);
-
- /* "View.MemoryView":499
- * result = struct.unpack(self.view.format, bytesitem)
- * except struct.error:
- * raise ValueError, "Unable to convert item to object" # <<<<<<<<<<<<<<
- * else:
- * if len(self.view.format) == 1:
- */
- __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Unable_to_convert_item_to_object, 0, 0);
- __PYX_ERR(1, 499, __pyx_L5_except_error)
- }
- goto __pyx_L5_except_error;
-
- /* "View.MemoryView":496
- *
- * bytesitem = itemp[:self.view.itemsize]
- * try: # <<<<<<<<<<<<<<
- * result = struct.unpack(self.view.format, bytesitem)
- * except struct.error:
- */
- __pyx_L5_except_error:;
- __Pyx_XGIVEREF(__pyx_t_2);
- __Pyx_XGIVEREF(__pyx_t_3);
- __Pyx_XGIVEREF(__pyx_t_4);
- __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
- goto __pyx_L1_error;
- __pyx_L6_except_return:;
- __Pyx_XGIVEREF(__pyx_t_2);
- __Pyx_XGIVEREF(__pyx_t_3);
- __Pyx_XGIVEREF(__pyx_t_4);
- __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
- goto __pyx_L0;
- }
-
- /* "View.MemoryView":489
- * self.assign_item_from_object(itemp, value)
- *
- * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<<
- * """Only used if instantiated manually by the user, or if Cython doesn't
- * know how to convert the type"""
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_1);
- __Pyx_XDECREF(__pyx_t_5);
- __Pyx_XDECREF(__pyx_t_6);
- __Pyx_XDECREF(__pyx_t_7);
- __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = 0;
- __pyx_L0:;
- __Pyx_XDECREF(__pyx_v_struct);
- __Pyx_XDECREF(__pyx_v_bytesitem);
- __Pyx_XDECREF(__pyx_v_result);
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":505
- * return result
- *
- * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<<
- * """Only used if instantiated manually by the user, or if Cython doesn't
- * know how to convert the type"""
- */
-
-static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) {
- PyObject *__pyx_v_struct = NULL;
- char __pyx_v_c;
- PyObject *__pyx_v_bytesvalue = 0;
- Py_ssize_t __pyx_v_i;
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- PyObject *__pyx_t_1 = NULL;
- int __pyx_t_2;
- PyObject *__pyx_t_3 = NULL;
- PyObject *__pyx_t_4 = NULL;
- PyObject *__pyx_t_5 = NULL;
- int __pyx_t_6;
- Py_ssize_t __pyx_t_7;
- PyObject *__pyx_t_8 = NULL;
- char *__pyx_t_9;
- char *__pyx_t_10;
- char *__pyx_t_11;
- char *__pyx_t_12;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("assign_item_from_object", 0);
-
- /* "View.MemoryView":508
- * """Only used if instantiated manually by the user, or if Cython doesn't
- * know how to convert the type"""
- * import struct # <<<<<<<<<<<<<<
- * cdef char c
- * cdef bytes bytesvalue
- */
- __pyx_t_1 = __Pyx_ImportDottedModule(__pyx_n_s_struct, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 508, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_v_struct = __pyx_t_1;
- __pyx_t_1 = 0;
-
- /* "View.MemoryView":513
- * cdef Py_ssize_t i
- *
- * if isinstance(value, tuple): # <<<<<<<<<<<<<<
- * bytesvalue = struct.pack(self.view.format, *value)
- * else:
- */
- __pyx_t_2 = PyTuple_Check(__pyx_v_value);
- if (__pyx_t_2) {
-
- /* "View.MemoryView":514
- *
- * if isinstance(value, tuple):
- * bytesvalue = struct.pack(self.view.format, *value) # <<<<<<<<<<<<<<
- * else:
- * bytesvalue = struct.pack(self.view.format, value)
- */
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 514, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_4);
- __Pyx_GIVEREF(__pyx_t_3);
- PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
- __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_3);
- __pyx_t_5 = PyNumber_Add(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 514, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_5);
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_3);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- if (!(likely(PyBytes_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_3))) __PYX_ERR(1, 514, __pyx_L1_error)
- __pyx_v_bytesvalue = ((PyObject*)__pyx_t_3);
- __pyx_t_3 = 0;
-
- /* "View.MemoryView":513
- * cdef Py_ssize_t i
- *
- * if isinstance(value, tuple): # <<<<<<<<<<<<<<
- * bytesvalue = struct.pack(self.view.format, *value)
- * else:
- */
- goto __pyx_L3;
- }
-
- /* "View.MemoryView":516
- * bytesvalue = struct.pack(self.view.format, *value)
- * else:
- * bytesvalue = struct.pack(self.view.format, value) # <<<<<<<<<<<<<<
- *
- * for i, c in enumerate(bytesvalue):
- */
- /*else*/ {
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 516, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_5);
- __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 516, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = NULL;
- __pyx_t_6 = 0;
- if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
- __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
- if (likely(__pyx_t_4)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
- __Pyx_INCREF(__pyx_t_4);
- __Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_5, function);
- __pyx_t_6 = 1;
- }
- }
- {
- PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_v_value};
- __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6);
- __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 516, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_3);
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- }
- if (!(likely(PyBytes_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_3))) __PYX_ERR(1, 516, __pyx_L1_error)
- __pyx_v_bytesvalue = ((PyObject*)__pyx_t_3);
- __pyx_t_3 = 0;
- }
- __pyx_L3:;
-
- /* "View.MemoryView":518
- * bytesvalue = struct.pack(self.view.format, value)
- *
- * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<<
- * itemp[i] = c
- *
- */
- __pyx_t_7 = 0;
- if (unlikely(__pyx_v_bytesvalue == Py_None)) {
- PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable");
- __PYX_ERR(1, 518, __pyx_L1_error)
- }
- __Pyx_INCREF(__pyx_v_bytesvalue);
- __pyx_t_8 = __pyx_v_bytesvalue;
- __pyx_t_10 = PyBytes_AS_STRING(__pyx_t_8);
- __pyx_t_11 = (__pyx_t_10 + PyBytes_GET_SIZE(__pyx_t_8));
- for (__pyx_t_12 = __pyx_t_10; __pyx_t_12 < __pyx_t_11; __pyx_t_12++) {
- __pyx_t_9 = __pyx_t_12;
- __pyx_v_c = (__pyx_t_9[0]);
-
- /* "View.MemoryView":519
- *
- * for i, c in enumerate(bytesvalue):
- * itemp[i] = c # <<<<<<<<<<<<<<
- *
- * @cname('getbuffer')
- */
- __pyx_v_i = __pyx_t_7;
-
- /* "View.MemoryView":518
- * bytesvalue = struct.pack(self.view.format, value)
- *
- * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<<
- * itemp[i] = c
- *
- */
- __pyx_t_7 = (__pyx_t_7 + 1);
-
- /* "View.MemoryView":519
- *
- * for i, c in enumerate(bytesvalue):
- * itemp[i] = c # <<<<<<<<<<<<<<
- *
- * @cname('getbuffer')
- */
- (__pyx_v_itemp[__pyx_v_i]) = __pyx_v_c;
- }
- __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-
- /* "View.MemoryView":505
- * return result
- *
- * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<<
- * """Only used if instantiated manually by the user, or if Cython doesn't
- * know how to convert the type"""
- */
-
- /* function exit code */
- __pyx_r = Py_None; __Pyx_INCREF(Py_None);
- goto __pyx_L0;
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_1);
- __Pyx_XDECREF(__pyx_t_3);
- __Pyx_XDECREF(__pyx_t_4);
- __Pyx_XDECREF(__pyx_t_5);
- __Pyx_XDECREF(__pyx_t_8);
- __Pyx_AddTraceback("View.MemoryView.memoryview.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = 0;
- __pyx_L0:;
- __Pyx_XDECREF(__pyx_v_struct);
- __Pyx_XDECREF(__pyx_v_bytesvalue);
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":521
- * itemp[i] = c
- *
- * @cname('getbuffer') # <<<<<<<<<<<<<<
- * def __getbuffer__(self, Py_buffer *info, int flags):
- * if flags & PyBUF_WRITABLE and self.view.readonly:
- */
-
-/* Python wrapper */
-CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
-CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- int __pyx_r;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
- __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
- int __pyx_r;
- __Pyx_RefNannyDeclarations
- int __pyx_t_1;
- int __pyx_t_2;
- Py_ssize_t *__pyx_t_3;
- char *__pyx_t_4;
- void *__pyx_t_5;
- int __pyx_t_6;
- Py_ssize_t __pyx_t_7;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- if (unlikely(__pyx_v_info == NULL)) {
- PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete");
- return -1;
- }
- __Pyx_RefNannySetupContext("__getbuffer__", 0);
- __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None);
- __Pyx_GIVEREF(__pyx_v_info->obj);
-
- /* "View.MemoryView":523
- * @cname('getbuffer')
- * def __getbuffer__(self, Py_buffer *info, int flags):
- * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<<
- * raise ValueError, "Cannot create writable memory view from read-only memoryview"
- *
- */
- __pyx_t_2 = ((__pyx_v_flags & PyBUF_WRITABLE) != 0);
- if (__pyx_t_2) {
- } else {
- __pyx_t_1 = __pyx_t_2;
- goto __pyx_L4_bool_binop_done;
- }
- __pyx_t_1 = __pyx_v_self->view.readonly;
- __pyx_L4_bool_binop_done:;
- if (unlikely(__pyx_t_1)) {
-
- /* "View.MemoryView":524
- * def __getbuffer__(self, Py_buffer *info, int flags):
- * if flags & PyBUF_WRITABLE and self.view.readonly:
- * raise ValueError, "Cannot create writable memory view from read-only memoryview" # <<<<<<<<<<<<<<
- *
- * if flags & PyBUF_ND:
- */
- __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Cannot_create_writable_memory_vi, 0, 0);
- __PYX_ERR(1, 524, __pyx_L1_error)
-
- /* "View.MemoryView":523
- * @cname('getbuffer')
- * def __getbuffer__(self, Py_buffer *info, int flags):
- * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<<
- * raise ValueError, "Cannot create writable memory view from read-only memoryview"
- *
- */
- }
-
- /* "View.MemoryView":526
- * raise ValueError, "Cannot create writable memory view from read-only memoryview"
- *
- * if flags & PyBUF_ND: # <<<<<<<<<<<<<<
- * info.shape = self.view.shape
- * else:
- */
- __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0);
- if (__pyx_t_1) {
-
- /* "View.MemoryView":527
- *
- * if flags & PyBUF_ND:
- * info.shape = self.view.shape # <<<<<<<<<<<<<<
- * else:
- * info.shape = NULL
- */
- __pyx_t_3 = __pyx_v_self->view.shape;
- __pyx_v_info->shape = __pyx_t_3;
-
- /* "View.MemoryView":526
- * raise ValueError, "Cannot create writable memory view from read-only memoryview"
- *
- * if flags & PyBUF_ND: # <<<<<<<<<<<<<<
- * info.shape = self.view.shape
- * else:
- */
- goto __pyx_L6;
- }
-
- /* "View.MemoryView":529
- * info.shape = self.view.shape
- * else:
- * info.shape = NULL # <<<<<<<<<<<<<<
- *
- * if flags & PyBUF_STRIDES:
- */
- /*else*/ {
- __pyx_v_info->shape = NULL;
- }
- __pyx_L6:;
-
- /* "View.MemoryView":531
- * info.shape = NULL
- *
- * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<<
- * info.strides = self.view.strides
- * else:
- */
- __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0);
- if (__pyx_t_1) {
-
- /* "View.MemoryView":532
- *
- * if flags & PyBUF_STRIDES:
- * info.strides = self.view.strides # <<<<<<<<<<<<<<
- * else:
- * info.strides = NULL
- */
- __pyx_t_3 = __pyx_v_self->view.strides;
- __pyx_v_info->strides = __pyx_t_3;
-
- /* "View.MemoryView":531
- * info.shape = NULL
- *
- * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<<
- * info.strides = self.view.strides
- * else:
- */
- goto __pyx_L7;
- }
-
- /* "View.MemoryView":534
- * info.strides = self.view.strides
- * else:
- * info.strides = NULL # <<<<<<<<<<<<<<
- *
- * if flags & PyBUF_INDIRECT:
- */
- /*else*/ {
- __pyx_v_info->strides = NULL;
- }
- __pyx_L7:;
-
- /* "View.MemoryView":536
- * info.strides = NULL
- *
- * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<<
- * info.suboffsets = self.view.suboffsets
- * else:
- */
- __pyx_t_1 = ((__pyx_v_flags & PyBUF_INDIRECT) != 0);
- if (__pyx_t_1) {
-
- /* "View.MemoryView":537
- *
- * if flags & PyBUF_INDIRECT:
- * info.suboffsets = self.view.suboffsets # <<<<<<<<<<<<<<
- * else:
- * info.suboffsets = NULL
- */
- __pyx_t_3 = __pyx_v_self->view.suboffsets;
- __pyx_v_info->suboffsets = __pyx_t_3;
-
- /* "View.MemoryView":536
- * info.strides = NULL
- *
- * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<<
- * info.suboffsets = self.view.suboffsets
- * else:
- */
- goto __pyx_L8;
- }
-
- /* "View.MemoryView":539
- * info.suboffsets = self.view.suboffsets
- * else:
- * info.suboffsets = NULL # <<<<<<<<<<<<<<
- *
- * if flags & PyBUF_FORMAT:
- */
- /*else*/ {
- __pyx_v_info->suboffsets = NULL;
- }
- __pyx_L8:;
-
- /* "View.MemoryView":541
- * info.suboffsets = NULL
- *
- * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<<
- * info.format = self.view.format
- * else:
- */
- __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0);
- if (__pyx_t_1) {
-
- /* "View.MemoryView":542
- *
- * if flags & PyBUF_FORMAT:
- * info.format = self.view.format # <<<<<<<<<<<<<<
- * else:
- * info.format = NULL
- */
- __pyx_t_4 = __pyx_v_self->view.format;
- __pyx_v_info->format = __pyx_t_4;
-
- /* "View.MemoryView":541
- * info.suboffsets = NULL
- *
- * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<<
- * info.format = self.view.format
- * else:
- */
- goto __pyx_L9;
- }
-
- /* "View.MemoryView":544
- * info.format = self.view.format
- * else:
- * info.format = NULL # <<<<<<<<<<<<<<
- *
- * info.buf = self.view.buf
- */
- /*else*/ {
- __pyx_v_info->format = NULL;
- }
- __pyx_L9:;
-
- /* "View.MemoryView":546
- * info.format = NULL
- *
- * info.buf = self.view.buf # <<<<<<<<<<<<<<
- * info.ndim = self.view.ndim
- * info.itemsize = self.view.itemsize
- */
- __pyx_t_5 = __pyx_v_self->view.buf;
- __pyx_v_info->buf = __pyx_t_5;
-
- /* "View.MemoryView":547
- *
- * info.buf = self.view.buf
- * info.ndim = self.view.ndim # <<<<<<<<<<<<<<
- * info.itemsize = self.view.itemsize
- * info.len = self.view.len
- */
- __pyx_t_6 = __pyx_v_self->view.ndim;
- __pyx_v_info->ndim = __pyx_t_6;
-
- /* "View.MemoryView":548
- * info.buf = self.view.buf
- * info.ndim = self.view.ndim
- * info.itemsize = self.view.itemsize # <<<<<<<<<<<<<<
- * info.len = self.view.len
- * info.readonly = self.view.readonly
- */
- __pyx_t_7 = __pyx_v_self->view.itemsize;
- __pyx_v_info->itemsize = __pyx_t_7;
-
- /* "View.MemoryView":549
- * info.ndim = self.view.ndim
- * info.itemsize = self.view.itemsize
- * info.len = self.view.len # <<<<<<<<<<<<<<
- * info.readonly = self.view.readonly
- * info.obj = self
- */
- __pyx_t_7 = __pyx_v_self->view.len;
- __pyx_v_info->len = __pyx_t_7;
-
- /* "View.MemoryView":550
- * info.itemsize = self.view.itemsize
- * info.len = self.view.len
- * info.readonly = self.view.readonly # <<<<<<<<<<<<<<
- * info.obj = self
- *
- */
- __pyx_t_1 = __pyx_v_self->view.readonly;
- __pyx_v_info->readonly = __pyx_t_1;
-
- /* "View.MemoryView":551
- * info.len = self.view.len
- * info.readonly = self.view.readonly
- * info.obj = self # <<<<<<<<<<<<<<
- *
- *
- */
- __Pyx_INCREF((PyObject *)__pyx_v_self);
- __Pyx_GIVEREF((PyObject *)__pyx_v_self);
- __Pyx_GOTREF(__pyx_v_info->obj);
- __Pyx_DECREF(__pyx_v_info->obj);
- __pyx_v_info->obj = ((PyObject *)__pyx_v_self);
-
- /* "View.MemoryView":521
- * itemp[i] = c
- *
- * @cname('getbuffer') # <<<<<<<<<<<<<<
- * def __getbuffer__(self, Py_buffer *info, int flags):
- * if flags & PyBUF_WRITABLE and self.view.readonly:
- */
-
- /* function exit code */
- __pyx_r = 0;
- goto __pyx_L0;
- __pyx_L1_error:;
- __Pyx_AddTraceback("View.MemoryView.memoryview.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = -1;
- if (__pyx_v_info->obj != NULL) {
- __Pyx_GOTREF(__pyx_v_info->obj);
- __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
- }
- goto __pyx_L2;
- __pyx_L0:;
- if (__pyx_v_info->obj == Py_None) {
- __Pyx_GOTREF(__pyx_v_info->obj);
- __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
- }
- __pyx_L2:;
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":554
- *
- *
- * @property # <<<<<<<<<<<<<<
- * def T(self):
- * cdef _memoryviewslice result = memoryview_copy(self)
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- PyObject *__pyx_r = 0;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
- __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
- struct __pyx_memoryviewslice_obj *__pyx_v_result = 0;
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- PyObject *__pyx_t_1 = NULL;
- int __pyx_t_2;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("__get__", 0);
-
- /* "View.MemoryView":556
- * @property
- * def T(self):
- * cdef _memoryviewslice result = memoryview_copy(self) # <<<<<<<<<<<<<<
- * transpose_memslice(&result.from_slice)
- * return result
- */
- __pyx_t_1 = __pyx_memoryview_copy_object(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 556, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_memoryviewslice_type))))) __PYX_ERR(1, 556, __pyx_L1_error)
- __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_1);
- __pyx_t_1 = 0;
-
- /* "View.MemoryView":557
- * def T(self):
- * cdef _memoryviewslice result = memoryview_copy(self)
- * transpose_memslice(&result.from_slice) # <<<<<<<<<<<<<<
- * return result
- *
- */
- __pyx_t_2 = __pyx_memslice_transpose((&__pyx_v_result->from_slice)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 557, __pyx_L1_error)
-
- /* "View.MemoryView":558
- * cdef _memoryviewslice result = memoryview_copy(self)
- * transpose_memslice(&result.from_slice)
- * return result # <<<<<<<<<<<<<<
- *
- * @property
- */
- __Pyx_XDECREF(__pyx_r);
- __Pyx_INCREF((PyObject *)__pyx_v_result);
- __pyx_r = ((PyObject *)__pyx_v_result);
- goto __pyx_L0;
-
- /* "View.MemoryView":554
- *
- *
- * @property # <<<<<<<<<<<<<<
- * def T(self):
- * cdef _memoryviewslice result = memoryview_copy(self)
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_1);
- __Pyx_AddTraceback("View.MemoryView.memoryview.T.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = NULL;
- __pyx_L0:;
- __Pyx_XDECREF((PyObject *)__pyx_v_result);
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":560
- * return result
- *
- * @property # <<<<<<<<<<<<<<
- * def base(self):
- * return self._get_base()
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- PyObject *__pyx_r = 0;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
- __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("__get__", 0);
-
- /* "View.MemoryView":562
- * @property
- * def base(self):
- * return self._get_base() # <<<<<<<<<<<<<<
- *
- * cdef _get_base(self):
- */
- __Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->_get_base(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 562, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_r = __pyx_t_1;
- __pyx_t_1 = 0;
- goto __pyx_L0;
-
- /* "View.MemoryView":560
- * return result
- *
- * @property # <<<<<<<<<<<<<<
- * def base(self):
- * return self._get_base()
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_1);
- __Pyx_AddTraceback("View.MemoryView.memoryview.base.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = NULL;
- __pyx_L0:;
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":564
- * return self._get_base()
- *
- * cdef _get_base(self): # <<<<<<<<<<<<<<
- * return self.obj
- *
- */
-
-static PyObject *__pyx_memoryview__get_base(struct __pyx_memoryview_obj *__pyx_v_self) {
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("_get_base", 0);
-
- /* "View.MemoryView":565
- *
- * cdef _get_base(self):
- * return self.obj # <<<<<<<<<<<<<<
- *
- * @property
- */
- __Pyx_XDECREF(__pyx_r);
- __Pyx_INCREF(__pyx_v_self->obj);
- __pyx_r = __pyx_v_self->obj;
- goto __pyx_L0;
-
- /* "View.MemoryView":564
- * return self._get_base()
- *
- * cdef _get_base(self): # <<<<<<<<<<<<<<
- * return self.obj
- *
- */
-
- /* function exit code */
- __pyx_L0:;
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":567
- * return self.obj
- *
- * @property # <<<<<<<<<<<<<<
- * def shape(self):
- * return tuple([length for length in self.view.shape[:self.view.ndim]])
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- PyObject *__pyx_r = 0;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
- __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
- Py_ssize_t __pyx_7genexpr__pyx_v_length;
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- PyObject *__pyx_t_1 = NULL;
- Py_ssize_t *__pyx_t_2;
- Py_ssize_t *__pyx_t_3;
- Py_ssize_t *__pyx_t_4;
- PyObject *__pyx_t_5 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("__get__", 0);
-
- /* "View.MemoryView":569
- * @property
- * def shape(self):
- * return tuple([length for length in self.view.shape[:self.view.ndim]]) # <<<<<<<<<<<<<<
- *
- * @property
- */
- __Pyx_XDECREF(__pyx_r);
- { /* enter inner scope */
- __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 569, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim);
- for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) {
- __pyx_t_2 = __pyx_t_4;
- __pyx_7genexpr__pyx_v_length = (__pyx_t_2[0]);
- __pyx_t_5 = PyInt_FromSsize_t(__pyx_7genexpr__pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 569, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_5);
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 569, __pyx_L1_error)
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- }
- } /* exit inner scope */
- __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 569, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_5);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_r = __pyx_t_5;
- __pyx_t_5 = 0;
- goto __pyx_L0;
-
- /* "View.MemoryView":567
- * return self.obj
- *
- * @property # <<<<<<<<<<<<<<
- * def shape(self):
- * return tuple([length for length in self.view.shape[:self.view.ndim]])
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_1);
- __Pyx_XDECREF(__pyx_t_5);
- __Pyx_AddTraceback("View.MemoryView.memoryview.shape.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = NULL;
- __pyx_L0:;
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":571
- * return tuple([length for length in self.view.shape[:self.view.ndim]])
- *
- * @property # <<<<<<<<<<<<<<
- * def strides(self):
- * if self.view.strides == NULL:
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- PyObject *__pyx_r = 0;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
- __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
- Py_ssize_t __pyx_8genexpr1__pyx_v_stride;
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- int __pyx_t_1;
- PyObject *__pyx_t_2 = NULL;
- Py_ssize_t *__pyx_t_3;
- Py_ssize_t *__pyx_t_4;
- Py_ssize_t *__pyx_t_5;
- PyObject *__pyx_t_6 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("__get__", 0);
-
- /* "View.MemoryView":573
- * @property
- * def strides(self):
- * if self.view.strides == NULL: # <<<<<<<<<<<<<<
- *
- * raise ValueError, "Buffer view does not expose strides"
- */
- __pyx_t_1 = (__pyx_v_self->view.strides == NULL);
- if (unlikely(__pyx_t_1)) {
-
- /* "View.MemoryView":575
- * if self.view.strides == NULL:
- *
- * raise ValueError, "Buffer view does not expose strides" # <<<<<<<<<<<<<<
- *
- * return tuple([stride for stride in self.view.strides[:self.view.ndim]])
- */
- __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Buffer_view_does_not_expose_stri, 0, 0);
- __PYX_ERR(1, 575, __pyx_L1_error)
-
- /* "View.MemoryView":573
- * @property
- * def strides(self):
- * if self.view.strides == NULL: # <<<<<<<<<<<<<<
- *
- * raise ValueError, "Buffer view does not expose strides"
- */
- }
-
- /* "View.MemoryView":577
- * raise ValueError, "Buffer view does not expose strides"
- *
- * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) # <<<<<<<<<<<<<<
- *
- * @property
- */
- __Pyx_XDECREF(__pyx_r);
- { /* enter inner scope */
- __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 577, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_2);
- __pyx_t_4 = (__pyx_v_self->view.strides + __pyx_v_self->view.ndim);
- for (__pyx_t_5 = __pyx_v_self->view.strides; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) {
- __pyx_t_3 = __pyx_t_5;
- __pyx_8genexpr1__pyx_v_stride = (__pyx_t_3[0]);
- __pyx_t_6 = PyInt_FromSsize_t(__pyx_8genexpr1__pyx_v_stride); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 577, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_6);
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 577, __pyx_L1_error)
- __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- }
- } /* exit inner scope */
- __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 577, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_6);
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_r = __pyx_t_6;
- __pyx_t_6 = 0;
- goto __pyx_L0;
-
- /* "View.MemoryView":571
- * return tuple([length for length in self.view.shape[:self.view.ndim]])
- *
- * @property # <<<<<<<<<<<<<<
- * def strides(self):
- * if self.view.strides == NULL:
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_2);
- __Pyx_XDECREF(__pyx_t_6);
- __Pyx_AddTraceback("View.MemoryView.memoryview.strides.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = NULL;
- __pyx_L0:;
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":579
- * return tuple([stride for stride in self.view.strides[:self.view.ndim]])
- *
- * @property # <<<<<<<<<<<<<<
- * def suboffsets(self):
- * if self.view.suboffsets == NULL:
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- PyObject *__pyx_r = 0;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
- __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
- Py_ssize_t __pyx_8genexpr2__pyx_v_suboffset;
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- int __pyx_t_1;
- PyObject *__pyx_t_2 = NULL;
- Py_ssize_t *__pyx_t_3;
- Py_ssize_t *__pyx_t_4;
- Py_ssize_t *__pyx_t_5;
- PyObject *__pyx_t_6 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("__get__", 0);
-
- /* "View.MemoryView":581
- * @property
- * def suboffsets(self):
- * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<<
- * return (-1,) * self.view.ndim
- *
- */
- __pyx_t_1 = (__pyx_v_self->view.suboffsets == NULL);
- if (__pyx_t_1) {
-
- /* "View.MemoryView":582
- * def suboffsets(self):
- * if self.view.suboffsets == NULL:
- * return (-1,) * self.view.ndim # <<<<<<<<<<<<<<
- *
- * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]])
- */
- __Pyx_XDECREF(__pyx_r);
- __pyx_t_2 = __Pyx_PySequence_Multiply(__pyx_tuple__4, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 582, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_2);
- __pyx_r = __pyx_t_2;
- __pyx_t_2 = 0;
- goto __pyx_L0;
-
- /* "View.MemoryView":581
- * @property
- * def suboffsets(self):
- * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<<
- * return (-1,) * self.view.ndim
- *
- */
- }
-
- /* "View.MemoryView":584
- * return (-1,) * self.view.ndim
- *
- * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) # <<<<<<<<<<<<<<
- *
- * @property
- */
- __Pyx_XDECREF(__pyx_r);
- { /* enter inner scope */
- __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 584, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_2);
- __pyx_t_4 = (__pyx_v_self->view.suboffsets + __pyx_v_self->view.ndim);
- for (__pyx_t_5 = __pyx_v_self->view.suboffsets; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) {
- __pyx_t_3 = __pyx_t_5;
- __pyx_8genexpr2__pyx_v_suboffset = (__pyx_t_3[0]);
- __pyx_t_6 = PyInt_FromSsize_t(__pyx_8genexpr2__pyx_v_suboffset); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 584, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_6);
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 584, __pyx_L1_error)
- __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- }
- } /* exit inner scope */
- __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 584, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_6);
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_r = __pyx_t_6;
- __pyx_t_6 = 0;
- goto __pyx_L0;
-
- /* "View.MemoryView":579
- * return tuple([stride for stride in self.view.strides[:self.view.ndim]])
- *
- * @property # <<<<<<<<<<<<<<
- * def suboffsets(self):
- * if self.view.suboffsets == NULL:
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_2);
- __Pyx_XDECREF(__pyx_t_6);
- __Pyx_AddTraceback("View.MemoryView.memoryview.suboffsets.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = NULL;
- __pyx_L0:;
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":586
- * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]])
- *
- * @property # <<<<<<<<<<<<<<
- * def ndim(self):
- * return self.view.ndim
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- PyObject *__pyx_r = 0;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
- __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("__get__", 0);
-
- /* "View.MemoryView":588
- * @property
- * def ndim(self):
- * return self.view.ndim # <<<<<<<<<<<<<<
- *
- * @property
- */
- __Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 588, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_r = __pyx_t_1;
- __pyx_t_1 = 0;
- goto __pyx_L0;
-
- /* "View.MemoryView":586
- * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]])
- *
- * @property # <<<<<<<<<<<<<<
- * def ndim(self):
- * return self.view.ndim
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_1);
- __Pyx_AddTraceback("View.MemoryView.memoryview.ndim.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = NULL;
- __pyx_L0:;
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":590
- * return self.view.ndim
- *
- * @property # <<<<<<<<<<<<<<
- * def itemsize(self):
- * return self.view.itemsize
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- PyObject *__pyx_r = 0;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
- __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("__get__", 0);
-
- /* "View.MemoryView":592
- * @property
- * def itemsize(self):
- * return self.view.itemsize # <<<<<<<<<<<<<<
- *
- * @property
- */
- __Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 592, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_r = __pyx_t_1;
- __pyx_t_1 = 0;
- goto __pyx_L0;
-
- /* "View.MemoryView":590
- * return self.view.ndim
- *
- * @property # <<<<<<<<<<<<<<
- * def itemsize(self):
- * return self.view.itemsize
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_1);
- __Pyx_AddTraceback("View.MemoryView.memoryview.itemsize.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = NULL;
- __pyx_L0:;
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":594
- * return self.view.itemsize
- *
- * @property # <<<<<<<<<<<<<<
- * def nbytes(self):
- * return self.size * self.view.itemsize
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- PyObject *__pyx_r = 0;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
- __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- PyObject *__pyx_t_1 = NULL;
- PyObject *__pyx_t_2 = NULL;
- PyObject *__pyx_t_3 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("__get__", 0);
-
- /* "View.MemoryView":596
- * @property
- * def nbytes(self):
- * return self.size * self.view.itemsize # <<<<<<<<<<<<<<
- *
- * @property
- */
- __Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 596, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 596, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 596, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_3);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_r = __pyx_t_3;
- __pyx_t_3 = 0;
- goto __pyx_L0;
-
- /* "View.MemoryView":594
- * return self.view.itemsize
- *
- * @property # <<<<<<<<<<<<<<
- * def nbytes(self):
- * return self.size * self.view.itemsize
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_1);
- __Pyx_XDECREF(__pyx_t_2);
- __Pyx_XDECREF(__pyx_t_3);
- __Pyx_AddTraceback("View.MemoryView.memoryview.nbytes.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = NULL;
- __pyx_L0:;
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":598
- * return self.size * self.view.itemsize
- *
- * @property # <<<<<<<<<<<<<<
- * def size(self):
- * if self._size is None:
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- PyObject *__pyx_r = 0;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
- __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
- PyObject *__pyx_v_result = NULL;
- PyObject *__pyx_v_length = NULL;
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- int __pyx_t_1;
- Py_ssize_t *__pyx_t_2;
- Py_ssize_t *__pyx_t_3;
- Py_ssize_t *__pyx_t_4;
- PyObject *__pyx_t_5 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("__get__", 0);
-
- /* "View.MemoryView":600
- * @property
- * def size(self):
- * if self._size is None: # <<<<<<<<<<<<<<
- * result = 1
- *
- */
- __pyx_t_1 = (__pyx_v_self->_size == Py_None);
- if (__pyx_t_1) {
-
- /* "View.MemoryView":601
- * def size(self):
- * if self._size is None:
- * result = 1 # <<<<<<<<<<<<<<
- *
- * for length in self.view.shape[:self.view.ndim]:
- */
- __Pyx_INCREF(__pyx_int_1);
- __pyx_v_result = __pyx_int_1;
-
- /* "View.MemoryView":603
- * result = 1
- *
- * for length in self.view.shape[:self.view.ndim]: # <<<<<<<<<<<<<<
- * result *= length
- *
- */
- __pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim);
- for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) {
- __pyx_t_2 = __pyx_t_4;
- __pyx_t_5 = PyInt_FromSsize_t((__pyx_t_2[0])); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 603, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_5);
- __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_5);
- __pyx_t_5 = 0;
-
- /* "View.MemoryView":604
- *
- * for length in self.view.shape[:self.view.ndim]:
- * result *= length # <<<<<<<<<<<<<<
- *
- * self._size = result
- */
- __pyx_t_5 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 604, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_5);
- __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_5);
- __pyx_t_5 = 0;
- }
-
- /* "View.MemoryView":606
- * result *= length
- *
- * self._size = result # <<<<<<<<<<<<<<
- *
- * return self._size
- */
- __Pyx_INCREF(__pyx_v_result);
- __Pyx_GIVEREF(__pyx_v_result);
- __Pyx_GOTREF(__pyx_v_self->_size);
- __Pyx_DECREF(__pyx_v_self->_size);
- __pyx_v_self->_size = __pyx_v_result;
-
- /* "View.MemoryView":600
- * @property
- * def size(self):
- * if self._size is None: # <<<<<<<<<<<<<<
- * result = 1
- *
- */
- }
-
- /* "View.MemoryView":608
- * self._size = result
- *
- * return self._size # <<<<<<<<<<<<<<
- *
- * def __len__(self):
- */
- __Pyx_XDECREF(__pyx_r);
- __Pyx_INCREF(__pyx_v_self->_size);
- __pyx_r = __pyx_v_self->_size;
- goto __pyx_L0;
-
- /* "View.MemoryView":598
- * return self.size * self.view.itemsize
- *
- * @property # <<<<<<<<<<<<<<
- * def size(self):
- * if self._size is None:
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_5);
- __Pyx_AddTraceback("View.MemoryView.memoryview.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = NULL;
- __pyx_L0:;
- __Pyx_XDECREF(__pyx_v_result);
- __Pyx_XDECREF(__pyx_v_length);
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":610
- * return self._size
- *
- * def __len__(self): # <<<<<<<<<<<<<<
- * if self.view.ndim >= 1:
- * return self.view.shape[0]
- */
-
-/* Python wrapper */
-static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self); /*proto*/
-static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- Py_ssize_t __pyx_r;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__len__ (wrapper)", 0);
- __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self) {
- Py_ssize_t __pyx_r;
- __Pyx_RefNannyDeclarations
- int __pyx_t_1;
- __Pyx_RefNannySetupContext("__len__", 0);
-
- /* "View.MemoryView":611
- *
- * def __len__(self):
- * if self.view.ndim >= 1: # <<<<<<<<<<<<<<
- * return self.view.shape[0]
- *
- */
- __pyx_t_1 = (__pyx_v_self->view.ndim >= 1);
- if (__pyx_t_1) {
-
- /* "View.MemoryView":612
- * def __len__(self):
- * if self.view.ndim >= 1:
- * return self.view.shape[0] # <<<<<<<<<<<<<<
- *
- * return 0
- */
- __pyx_r = (__pyx_v_self->view.shape[0]);
- goto __pyx_L0;
-
- /* "View.MemoryView":611
- *
- * def __len__(self):
- * if self.view.ndim >= 1: # <<<<<<<<<<<<<<
- * return self.view.shape[0]
- *
- */
- }
-
- /* "View.MemoryView":614
- * return self.view.shape[0]
- *
- * return 0 # <<<<<<<<<<<<<<
- *
- * def __repr__(self):
- */
- __pyx_r = 0;
- goto __pyx_L0;
-
- /* "View.MemoryView":610
- * return self._size
- *
- * def __len__(self): # <<<<<<<<<<<<<<
- * if self.view.ndim >= 1:
- * return self.view.shape[0]
- */
-
- /* function exit code */
- __pyx_L0:;
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":616
- * return 0
- *
- * def __repr__(self): # <<<<<<<<<<<<<<
- * return "" % (self.base.__class__.__name__,
- * id(self))
- */
-
-/* Python wrapper */
-static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self) {
- CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
- PyObject *__pyx_r = 0;
- __Pyx_RefNannyDeclarations
- __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
- __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(((struct __pyx_memoryview_obj *)__pyx_v_self));
-
- /* function exit code */
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self) {
- PyObject *__pyx_r = NULL;
- __Pyx_RefNannyDeclarations
- PyObject *__pyx_t_1 = NULL;
- PyObject *__pyx_t_2 = NULL;
- PyObject *__pyx_t_3 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
- __Pyx_RefNannySetupContext("__repr__", 0);
-
- /* "View.MemoryView":617
- *
- * def __repr__(self):
- * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<<
- * id(self))
- *
- */
- __Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 617, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 617, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_2);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 617, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_1);
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
- /* "View.MemoryView":618
- * def __repr__(self):
- * return "" % (self.base.__class__.__name__,
- * id(self)) # <<<<<<<<<<<<<<
- *
- * def __str__(self):
- */
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 618, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_2);
-
- /* "View.MemoryView":617
- *
- * def __repr__(self):
- * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<<
- * id(self))
- *
- */
- __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 617, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_3);
- __Pyx_GIVEREF(__pyx_t_1);
- PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
- __Pyx_GIVEREF(__pyx_t_2);
- PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
- __pyx_t_1 = 0;
- __pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 617, __pyx_L1_error)
- __Pyx_GOTREF(__pyx_t_2);
- __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_r = __pyx_t_2;
- __pyx_t_2 = 0;
- goto __pyx_L0;
-
- /* "View.MemoryView":616
- * return 0
- *
- * def __repr__(self): # <<<<<<<<<<<<<<
- * return "" % (self.base.__class__.__name__,
- * id(self))
- */
-
- /* function exit code */
- __pyx_L1_error:;
- __Pyx_XDECREF(__pyx_t_1);
- __Pyx_XDECREF(__pyx_t_2);
- __Pyx_XDECREF(__pyx_t_3);
- __Pyx_AddTraceback("View.MemoryView.memoryview.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- __pyx_r = NULL;
- __pyx_L0:;
- __Pyx_XGIVEREF(__pyx_r);
- __Pyx_RefNannyFinishContext();
- return __pyx_r;
-}
-
-/* "View.MemoryView":620
- * id(self))
- *
- * def __str__(self): # <<<<<<<<<<<<<<
- * return "
'
- msg = msg.replace('If you liked don't forget to 💖 the project 🥰
-Parameters:
--
-
- message: what you want to say to the NPC. -
- npc_name: name of the NPC. -
- npc_prompt: prompt of the NPC, we can modify it to see if results are better. -
- top_p: control how deterministic the model is in generating a response. -
- temperature: (sampling temperature) higher values means the model will take more risks. -
- max_new_tokens: Max number of tokens in generation. -
"""
-theme="huggingface"
-
-
-# Builds the prompt from what previously happened
-def build_prompt(conversation, context, interlocutor_names):
- prompt = context + "\n"
- for player_msg, npc_msg in conversation:
- line = "\n- " + interlocutor_names[0] + ":" + player_msg
- prompt += line
- line = "\n- " + interlocutor_names[1] + ":" + npc_msg
- prompt += line
- prompt += ""
- return prompt
-
-# Recognize what the model said, if it used the correct format
-def clean_chat_output(txt, prompt, interlocutor_names):
- delimiter = "\n- "+interlocutor_names[0]
- output = txt.replace(prompt, '')
- output = output[:output.find(delimiter)]
- return output
-
-# GPT-J-6B API
-API_URL = "https://api-inference.huggingface.co/models/EleutherAI/gpt-j-6B"
-def query(payload):
- response = requests.post(API_URL, json=payload)
- return response.json()
-
-def chat(message, npc_name, initial_prompt, top_p, temperature, max_new_tokens, history=[]):
- interlocutor_names = ["Player", npc_name]
-
- print("message", message)
- print("npc_name", npc_name)
- print("initial_prompt", initial_prompt)
- print("top_p", top_p)
- print("temperature", temperature)
- print("max_new_tokens", max_new_tokens)
- print("history", history)
- response = "Test"
- history.append((message, ""))
- conversation = history
-
- # Build the prompt
- prompt = build_prompt(conversation, initial_prompt, interlocutor_names)
-
- # Build JSON
- json_req = {"inputs": prompt,
- "parameters":
- {
- "top_p": top_p,
- "temperature": temperature,
- "max_new_tokens": max_new_tokens,
- "return_full_text": False
- }}
-
- # Get the output
- output = query(json_req)
- output = output[0]['generated_text']
- print("output", output)
-
- answer = clean_chat_output(output, prompt, interlocutor_names)
- response = answer
- print("response", answer)
- history[-1] = (message, response)
- return history, history
-
-
-#io = gr.Interface.load("huggingface/EleutherAI/gpt-j-6B")
-
-iface = gr.Interface(fn=chat,
-inputs=[Textbox(label="message", placeholder="Hello!"),
- Textbox(label="npc_name", placeholder="Antoine"),
- Textbox(label="initial_prompt", placeholder="The following is a conversation with Antoine, a guard for Northfall that's drinking in the Tavern."),
- Slider(minimum=0.5, maximum=1, step=0.05, default=0.9, label="top_p"),
- Slider(minimum=0.5, maximum=1.5, step=0.1, default=1.1, label="temperature"),
- Slider(minimum=20, maximum=250, step=10, default=50, label="max_new_tokens"),
- "state"],
- outputs=["chatbot","state"],
- #examples = [["Hello!", "", , 0.9, 1.1, 50, iface.state]],
- allow_screenshot=True,
- allow_flagging=True,
- title=title,
- article=article,
- theme=theme)
-
-if __name__ == "__main__":
- iface.launch()
\ No newline at end of file
diff --git a/spaces/TushDeMort/yolo/utils/torch_utils.py b/spaces/TushDeMort/yolo/utils/torch_utils.py
deleted file mode 100644
index 1e631b555508457a4944c11a479176463719c0e8..0000000000000000000000000000000000000000
--- a/spaces/TushDeMort/yolo/utils/torch_utils.py
+++ /dev/null
@@ -1,374 +0,0 @@
-# YOLOR PyTorch utils
-
-import datetime
-import logging
-import math
-import os
-import platform
-import subprocess
-import time
-from contextlib import contextmanager
-from copy import deepcopy
-from pathlib import Path
-
-import torch
-import torch.backends.cudnn as cudnn
-import torch.nn as nn
-import torch.nn.functional as F
-import torchvision
-
-try:
- import thop # for FLOPS computation
-except ImportError:
- thop = None
-logger = logging.getLogger(__name__)
-
-
-@contextmanager
-def torch_distributed_zero_first(local_rank: int):
- """
- Decorator to make all processes in distributed training wait for each local_master to do something.
- """
- if local_rank not in [-1, 0]:
- torch.distributed.barrier()
- yield
- if local_rank == 0:
- torch.distributed.barrier()
-
-
-def init_torch_seeds(seed=0):
- # Speed-reproducibility tradeoff https://pytorch.org/docs/stable/notes/randomness.html
- torch.manual_seed(seed)
- if seed == 0: # slower, more reproducible
- cudnn.benchmark, cudnn.deterministic = False, True
- else: # faster, less reproducible
- cudnn.benchmark, cudnn.deterministic = True, False
-
-
-def date_modified(path=__file__):
- # return human-readable file modification date, i.e. '2021-3-26'
- t = datetime.datetime.fromtimestamp(Path(path).stat().st_mtime)
- return f'{t.year}-{t.month}-{t.day}'
-
-
-def git_describe(path=Path(__file__).parent): # path must be a directory
- # return human-readable git description, i.e. v5.0-5-g3e25f1e https://git-scm.com/docs/git-describe
- s = f'git -C {path} describe --tags --long --always'
- try:
- return subprocess.check_output(s, shell=True, stderr=subprocess.STDOUT).decode()[:-1]
- except subprocess.CalledProcessError as e:
- return '' # not a git repository
-
-
-def select_device(device='', batch_size=None):
- # device = 'cpu' or '0' or '0,1,2,3'
- s = f'YOLOR 🚀 {git_describe() or date_modified()} torch {torch.__version__} ' # string
- cpu = device.lower() == 'cpu'
- if cpu:
- os.environ['CUDA_VISIBLE_DEVICES'] = '-1' # force torch.cuda.is_available() = False
- elif device: # non-cpu device requested
- os.environ['CUDA_VISIBLE_DEVICES'] = device # set environment variable
- assert torch.cuda.is_available(), f'CUDA unavailable, invalid device {device} requested' # check availability
-
- cuda = not cpu and torch.cuda.is_available()
- if cuda:
- n = torch.cuda.device_count()
- if n > 1 and batch_size: # check that batch_size is compatible with device_count
- assert batch_size % n == 0, f'batch-size {batch_size} not multiple of GPU count {n}'
- space = ' ' * len(s)
- for i, d in enumerate(device.split(',') if device else range(n)):
- p = torch.cuda.get_device_properties(i)
- s += f"{'' if i == 0 else space}CUDA:{d} ({p.name}, {p.total_memory / 1024 ** 2}MB)\n" # bytes to MB
- else:
- s += 'CPU\n'
-
- logger.info(s.encode().decode('ascii', 'ignore') if platform.system() == 'Windows' else s) # emoji-safe
- return torch.device('cuda:0' if cuda else 'cpu')
-
-
-def time_synchronized():
- # pytorch-accurate time
- if torch.cuda.is_available():
- torch.cuda.synchronize()
- return time.time()
-
-
-def profile(x, ops, n=100, device=None):
- # profile a pytorch module or list of modules. Example usage:
- # x = torch.randn(16, 3, 640, 640) # input
- # m1 = lambda x: x * torch.sigmoid(x)
- # m2 = nn.SiLU()
- # profile(x, [m1, m2], n=100) # profile speed over 100 iterations
-
- device = device or torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
- x = x.to(device)
- x.requires_grad = True
- print(torch.__version__, device.type, torch.cuda.get_device_properties(0) if device.type == 'cuda' else '')
- print(f"\n{'Params':>12s}{'GFLOPS':>12s}{'forward (ms)':>16s}{'backward (ms)':>16s}{'input':>24s}{'output':>24s}")
- for m in ops if isinstance(ops, list) else [ops]:
- m = m.to(device) if hasattr(m, 'to') else m # device
- m = m.half() if hasattr(m, 'half') and isinstance(x, torch.Tensor) and x.dtype is torch.float16 else m # type
- dtf, dtb, t = 0., 0., [0., 0., 0.] # dt forward, backward
- try:
- flops = thop.profile(m, inputs=(x,), verbose=False)[0] / 1E9 * 2 # GFLOPS
- except:
- flops = 0
-
- for _ in range(n):
- t[0] = time_synchronized()
- y = m(x)
- t[1] = time_synchronized()
- try:
- _ = y.sum().backward()
- t[2] = time_synchronized()
- except: # no backward method
- t[2] = float('nan')
- dtf += (t[1] - t[0]) * 1000 / n # ms per op forward
- dtb += (t[2] - t[1]) * 1000 / n # ms per op backward
-
- s_in = tuple(x.shape) if isinstance(x, torch.Tensor) else 'list'
- s_out = tuple(y.shape) if isinstance(y, torch.Tensor) else 'list'
- p = sum(list(x.numel() for x in m.parameters())) if isinstance(m, nn.Module) else 0 # parameters
- print(f'{p:12}{flops:12.4g}{dtf:16.4g}{dtb:16.4g}{str(s_in):>24s}{str(s_out):>24s}')
-
-
-def is_parallel(model):
- return type(model) in (nn.parallel.DataParallel, nn.parallel.DistributedDataParallel)
-
-
-def intersect_dicts(da, db, exclude=()):
- # Dictionary intersection of matching keys and shapes, omitting 'exclude' keys, using da values
- return {k: v for k, v in da.items() if k in db and not any(x in k for x in exclude) and v.shape == db[k].shape}
-
-
-def initialize_weights(model):
- for m in model.modules():
- t = type(m)
- if t is nn.Conv2d:
- pass # nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
- elif t is nn.BatchNorm2d:
- m.eps = 1e-3
- m.momentum = 0.03
- elif t in [nn.Hardswish, nn.LeakyReLU, nn.ReLU, nn.ReLU6]:
- m.inplace = True
-
-
-def find_modules(model, mclass=nn.Conv2d):
- # Finds layer indices matching module class 'mclass'
- return [i for i, m in enumerate(model.module_list) if isinstance(m, mclass)]
-
-
-def sparsity(model):
- # Return global model sparsity
- a, b = 0., 0.
- for p in model.parameters():
- a += p.numel()
- b += (p == 0).sum()
- return b / a
-
-
-def prune(model, amount=0.3):
- # Prune model to requested global sparsity
- import torch.nn.utils.prune as prune
- print('Pruning model... ', end='')
- for name, m in model.named_modules():
- if isinstance(m, nn.Conv2d):
- prune.l1_unstructured(m, name='weight', amount=amount) # prune
- prune.remove(m, 'weight') # make permanent
- print(' %.3g global sparsity' % sparsity(model))
-
-
-def fuse_conv_and_bn(conv, bn):
- # Fuse convolution and batchnorm layers https://tehnokv.com/posts/fusing-batchnorm-and-conv/
- fusedconv = nn.Conv2d(conv.in_channels,
- conv.out_channels,
- kernel_size=conv.kernel_size,
- stride=conv.stride,
- padding=conv.padding,
- groups=conv.groups,
- bias=True).requires_grad_(False).to(conv.weight.device)
-
- # prepare filters
- w_conv = conv.weight.clone().view(conv.out_channels, -1)
- w_bn = torch.diag(bn.weight.div(torch.sqrt(bn.eps + bn.running_var)))
- fusedconv.weight.copy_(torch.mm(w_bn, w_conv).view(fusedconv.weight.shape))
-
- # prepare spatial bias
- b_conv = torch.zeros(conv.weight.size(0), device=conv.weight.device) if conv.bias is None else conv.bias
- b_bn = bn.bias - bn.weight.mul(bn.running_mean).div(torch.sqrt(bn.running_var + bn.eps))
- fusedconv.bias.copy_(torch.mm(w_bn, b_conv.reshape(-1, 1)).reshape(-1) + b_bn)
-
- return fusedconv
-
-
-def model_info(model, verbose=False, img_size=640):
- # Model information. img_size may be int or list, i.e. img_size=640 or img_size=[640, 320]
- n_p = sum(x.numel() for x in model.parameters()) # number parameters
- n_g = sum(x.numel() for x in model.parameters() if x.requires_grad) # number gradients
- if verbose:
- print('%5s %40s %9s %12s %20s %10s %10s' % ('layer', 'name', 'gradient', 'parameters', 'shape', 'mu', 'sigma'))
- for i, (name, p) in enumerate(model.named_parameters()):
- name = name.replace('module_list.', '')
- print('%5g %40s %9s %12g %20s %10.3g %10.3g' %
- (i, name, p.requires_grad, p.numel(), list(p.shape), p.mean(), p.std()))
-
- try: # FLOPS
- from thop import profile
- stride = max(int(model.stride.max()), 32) if hasattr(model, 'stride') else 32
- img = torch.zeros((1, model.yaml.get('ch', 3), stride, stride), device=next(model.parameters()).device) # input
- flops = profile(deepcopy(model), inputs=(img,), verbose=False)[0] / 1E9 * 2 # stride GFLOPS
- img_size = img_size if isinstance(img_size, list) else [img_size, img_size] # expand if int/float
- fs = ', %.1f GFLOPS' % (flops * img_size[0] / stride * img_size[1] / stride) # 640x640 GFLOPS
- except (ImportError, Exception):
- fs = ''
-
- logger.info(f"Model Summary: {len(list(model.modules()))} layers, {n_p} parameters, {n_g} gradients{fs}")
-
-
-def load_classifier(name='resnet101', n=2):
- # Loads a pretrained model reshaped to n-class output
- model = torchvision.models.__dict__[name](pretrained=True)
-
- # ResNet model properties
- # input_size = [3, 224, 224]
- # input_space = 'RGB'
- # input_range = [0, 1]
- # mean = [0.485, 0.456, 0.406]
- # std = [0.229, 0.224, 0.225]
-
- # Reshape output to n classes
- filters = model.fc.weight.shape[1]
- model.fc.bias = nn.Parameter(torch.zeros(n), requires_grad=True)
- model.fc.weight = nn.Parameter(torch.zeros(n, filters), requires_grad=True)
- model.fc.out_features = n
- return model
-
-
-def scale_img(img, ratio=1.0, same_shape=False, gs=32): # img(16,3,256,416)
- # scales img(bs,3,y,x) by ratio constrained to gs-multiple
- if ratio == 1.0:
- return img
- else:
- h, w = img.shape[2:]
- s = (int(h * ratio), int(w * ratio)) # new size
- img = F.interpolate(img, size=s, mode='bilinear', align_corners=False) # resize
- if not same_shape: # pad/crop img
- h, w = [math.ceil(x * ratio / gs) * gs for x in (h, w)]
- return F.pad(img, [0, w - s[1], 0, h - s[0]], value=0.447) # value = imagenet mean
-
-
-def copy_attr(a, b, include=(), exclude=()):
- # Copy attributes from b to a, options to only include [...] and to exclude [...]
- for k, v in b.__dict__.items():
- if (len(include) and k not in include) or k.startswith('_') or k in exclude:
- continue
- else:
- setattr(a, k, v)
-
-
-class ModelEMA:
- """ Model Exponential Moving Average from https://github.com/rwightman/pytorch-image-models
- Keep a moving average of everything in the model state_dict (parameters and buffers).
- This is intended to allow functionality like
- https://www.tensorflow.org/api_docs/python/tf/train/ExponentialMovingAverage
- A smoothed version of the weights is necessary for some training schemes to perform well.
- This class is sensitive where it is initialized in the sequence of model init,
- GPU assignment and distributed training wrappers.
- """
-
- def __init__(self, model, decay=0.9999, updates=0):
- # Create EMA
- self.ema = deepcopy(model.module if is_parallel(model) else model).eval() # FP32 EMA
- # if next(model.parameters()).device.type != 'cpu':
- # self.ema.half() # FP16 EMA
- self.updates = updates # number of EMA updates
- self.decay = lambda x: decay * (1 - math.exp(-x / 2000)) # decay exponential ramp (to help early epochs)
- for p in self.ema.parameters():
- p.requires_grad_(False)
-
- def update(self, model):
- # Update EMA parameters
- with torch.no_grad():
- self.updates += 1
- d = self.decay(self.updates)
-
- msd = model.module.state_dict() if is_parallel(model) else model.state_dict() # model state_dict
- for k, v in self.ema.state_dict().items():
- if v.dtype.is_floating_point:
- v *= d
- v += (1. - d) * msd[k].detach()
-
- def update_attr(self, model, include=(), exclude=('process_group', 'reducer')):
- # Update EMA attributes
- copy_attr(self.ema, model, include, exclude)
-
-
-class BatchNormXd(torch.nn.modules.batchnorm._BatchNorm):
- def _check_input_dim(self, input):
- # The only difference between BatchNorm1d, BatchNorm2d, BatchNorm3d, etc
- # is this method that is overwritten by the sub-class
- # This original goal of this method was for tensor sanity checks
- # If you're ok bypassing those sanity checks (eg. if you trust your inference
- # to provide the right dimensional inputs), then you can just use this method
- # for easy conversion from SyncBatchNorm
- # (unfortunately, SyncBatchNorm does not store the original class - if it did
- # we could return the one that was originally created)
- return
-
-def revert_sync_batchnorm(module):
- # this is very similar to the function that it is trying to revert:
- # https://github.com/pytorch/pytorch/blob/c8b3686a3e4ba63dc59e5dcfe5db3430df256833/torch/nn/modules/batchnorm.py#L679
- module_output = module
- if isinstance(module, torch.nn.modules.batchnorm.SyncBatchNorm):
- new_cls = BatchNormXd
- module_output = BatchNormXd(module.num_features,
- module.eps, module.momentum,
- module.affine,
- module.track_running_stats)
- if module.affine:
- with torch.no_grad():
- module_output.weight = module.weight
- module_output.bias = module.bias
- module_output.running_mean = module.running_mean
- module_output.running_var = module.running_var
- module_output.num_batches_tracked = module.num_batches_tracked
- if hasattr(module, "qconfig"):
- module_output.qconfig = module.qconfig
- for name, child in module.named_children():
- module_output.add_module(name, revert_sync_batchnorm(child))
- del module
- return module_output
-
-
-class TracedModel(nn.Module):
-
- def __init__(self, model=None, device=None, img_size=(640,640)):
- super(TracedModel, self).__init__()
-
- print(" Convert model to Traced-model... ")
- self.stride = model.stride
- self.names = model.names
- self.model = model
-
- self.model = revert_sync_batchnorm(self.model)
- self.model.to('cpu')
- self.model.eval()
-
- self.detect_layer = self.model.model[-1]
- self.model.traced = True
-
- rand_example = torch.rand(1, 3, img_size, img_size)
-
- traced_script_module = torch.jit.trace(self.model, rand_example, strict=False)
- #traced_script_module = torch.jit.script(self.model)
- traced_script_module.save("traced_model.pt")
- print(" traced_script_module saved! ")
- self.model = traced_script_module
- self.model.to(device)
- self.detect_layer.to(device)
- print(" model is traced! \n")
-
- def forward(self, x, augment=False, profile=False):
- out = self.model(x)
- out = self.detect_layer(out)
- return out
\ No newline at end of file
diff --git a/spaces/UzNutq/README/README.md b/spaces/UzNutq/README/README.md
deleted file mode 100644
index 67bde24474b2ddeb20470f34662efd907766da3e..0000000000000000000000000000000000000000
--- a/spaces/UzNutq/README/README.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: README
-emoji: 💻
-colorFrom: yellow
-colorTo: blue
-sdk: static
-pinned: true
----
-
-Edit this `README.md` markdown file to author your organization card 🔥
diff --git a/spaces/Venafi/Vikram-Explorer/README.md b/spaces/Venafi/Vikram-Explorer/README.md
deleted file mode 100644
index e0d49ac46a1c41b31bcb504432018f8144e4c561..0000000000000000000000000000000000000000
--- a/spaces/Venafi/Vikram-Explorer/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Vikram Explorer Project
-emoji: 🚀
-colorFrom: gray
-colorTo: gray
-sdk: gradio
-sdk_version: 3.42.0
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/VickyKira/NASAGPT/g4f/Provider/Provider.py b/spaces/VickyKira/NASAGPT/g4f/Provider/Provider.py
deleted file mode 100644
index d24df76b6a6ccfc9b244f13a51bfc124b398a271..0000000000000000000000000000000000000000
--- a/spaces/VickyKira/NASAGPT/g4f/Provider/Provider.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import os
-from ..typing import sha256, Dict, get_type_hints
-
-url = None
-model = None
-supports_stream = False
-needs_auth = False
-
-
-def _create_completion(model: str, messages: list, stream: bool, **kwargs):
- return
-
-
-params = f'g4f.Providers.{os.path.basename(__file__)[:-3]} supports: ' + \
- '(%s)' % ', '.join(
- [f"{name}: {get_type_hints(_create_completion)[name].__name__}" for name in _create_completion.__code__.co_varnames[:_create_completion.__code__.co_argcount]])
diff --git a/spaces/VideoCrafter/VideoCrafter/lvdm/modules/attention.py b/spaces/VideoCrafter/VideoCrafter/lvdm/modules/attention.py
deleted file mode 100644
index 3d3140c216b85a14a33d9b1fa09eb6d19465f741..0000000000000000000000000000000000000000
--- a/spaces/VideoCrafter/VideoCrafter/lvdm/modules/attention.py
+++ /dev/null
@@ -1,475 +0,0 @@
-from functools import partial
-import torch
-from torch import nn, einsum
-import torch.nn.functional as F
-from einops import rearrange, repeat
-try:
- import xformers
- import xformers.ops
- XFORMERS_IS_AVAILBLE = True
-except:
- XFORMERS_IS_AVAILBLE = False
-from lvdm.common import (
- checkpoint,
- exists,
- default,
-)
-from lvdm.basics import (
- zero_module,
-)
-
-class RelativePosition(nn.Module):
- """ https://github.com/evelinehong/Transformer_Relative_Position_PyTorch/blob/master/relative_position.py """
-
- def __init__(self, num_units, max_relative_position):
- super().__init__()
- self.num_units = num_units
- self.max_relative_position = max_relative_position
- self.embeddings_table = nn.Parameter(torch.Tensor(max_relative_position * 2 + 1, num_units))
- nn.init.xavier_uniform_(self.embeddings_table)
-
- def forward(self, length_q, length_k):
- device = self.embeddings_table.device
- range_vec_q = torch.arange(length_q, device=device)
- range_vec_k = torch.arange(length_k, device=device)
- distance_mat = range_vec_k[None, :] - range_vec_q[:, None]
- distance_mat_clipped = torch.clamp(distance_mat, -self.max_relative_position, self.max_relative_position)
- final_mat = distance_mat_clipped + self.max_relative_position
- final_mat = final_mat.long()
- embeddings = self.embeddings_table[final_mat]
- return embeddings
-
-
-class CrossAttention(nn.Module):
-
- def __init__(self, query_dim, context_dim=None, heads=8, dim_head=64, dropout=0.,
- relative_position=False, temporal_length=None, img_cross_attention=False):
- super().__init__()
- inner_dim = dim_head * heads
- context_dim = default(context_dim, query_dim)
-
- self.scale = dim_head**-0.5
- self.heads = heads
- self.dim_head = dim_head
- self.to_q = nn.Linear(query_dim, inner_dim, bias=False)
- self.to_k = nn.Linear(context_dim, inner_dim, bias=False)
- self.to_v = nn.Linear(context_dim, inner_dim, bias=False)
- self.to_out = nn.Sequential(nn.Linear(inner_dim, query_dim), nn.Dropout(dropout))
-
- self.image_cross_attention_scale = 1.0
- self.text_context_len = 77
- self.img_cross_attention = img_cross_attention
- if self.img_cross_attention:
- self.to_k_ip = nn.Linear(context_dim, inner_dim, bias=False)
- self.to_v_ip = nn.Linear(context_dim, inner_dim, bias=False)
-
- self.relative_position = relative_position
- if self.relative_position:
- assert(temporal_length is not None)
- self.relative_position_k = RelativePosition(num_units=dim_head, max_relative_position=temporal_length)
- self.relative_position_v = RelativePosition(num_units=dim_head, max_relative_position=temporal_length)
- else:
- ## only used for spatial attention, while NOT for temporal attention
- if XFORMERS_IS_AVAILBLE and temporal_length is None:
- self.forward = self.efficient_forward
-
- def forward(self, x, context=None, mask=None):
- h = self.heads
-
- q = self.to_q(x)
- context = default(context, x)
- ## considering image token additionally
- if context is not None and self.img_cross_attention:
- context, context_img = context[:,:self.text_context_len,:], context[:,self.text_context_len:,:]
- k = self.to_k(context)
- v = self.to_v(context)
- k_ip = self.to_k_ip(context_img)
- v_ip = self.to_v_ip(context_img)
- else:
- k = self.to_k(context)
- v = self.to_v(context)
-
- q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h), (q, k, v))
- sim = torch.einsum('b i d, b j d -> b i j', q, k) * self.scale
- if self.relative_position:
- len_q, len_k, len_v = q.shape[1], k.shape[1], v.shape[1]
- k2 = self.relative_position_k(len_q, len_k)
- sim2 = einsum('b t d, t s d -> b t s', q, k2) * self.scale # TODO check
- sim += sim2
- del k
-
- if exists(mask):
- ## feasible for causal attention mask only
- max_neg_value = -torch.finfo(sim.dtype).max
- mask = repeat(mask, 'b i j -> (b h) i j', h=h)
- sim.masked_fill_(~(mask>0.5), max_neg_value)
-
- # attention, what we cannot get enough of
- sim = sim.softmax(dim=-1)
- out = torch.einsum('b i j, b j d -> b i d', sim, v)
- if self.relative_position:
- v2 = self.relative_position_v(len_q, len_v)
- out2 = einsum('b t s, t s d -> b t d', sim, v2) # TODO check
- out += out2
- out = rearrange(out, '(b h) n d -> b n (h d)', h=h)
-
- ## considering image token additionally
- if context is not None and self.img_cross_attention:
- k_ip, v_ip = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h), (k_ip, v_ip))
- sim_ip = torch.einsum('b i d, b j d -> b i j', q, k_ip) * self.scale
- del k_ip
- sim_ip = sim_ip.softmax(dim=-1)
- out_ip = torch.einsum('b i j, b j d -> b i d', sim_ip, v_ip)
- out_ip = rearrange(out, '(b h) n d -> b n (h d)', h=h)
- out = out + self.image_cross_attention_scale * out_ip
- del q
-
- return self.to_out(out)
-
- def efficient_forward(self, x, context=None, mask=None):
- q = self.to_q(x)
- context = default(context, x)
-
- ## considering image token additionally
- if context is not None and self.img_cross_attention:
- context, context_img = context[:,:self.text_context_len,:], context[:,self.text_context_len:,:]
- k = self.to_k(context)
- v = self.to_v(context)
- k_ip = self.to_k_ip(context_img)
- v_ip = self.to_v_ip(context_img)
- else:
- k = self.to_k(context)
- v = self.to_v(context)
-
- b, _, _ = q.shape
- q, k, v = map(
- lambda t: t.unsqueeze(3)
- .reshape(b, t.shape[1], self.heads, self.dim_head)
- .permute(0, 2, 1, 3)
- .reshape(b * self.heads, t.shape[1], self.dim_head)
- .contiguous(),
- (q, k, v),
- )
- # actually compute the attention, what we cannot get enough of
- out = xformers.ops.memory_efficient_attention(q, k, v, attn_bias=None, op=None)
-
- ## considering image token additionally
- if context is not None and self.img_cross_attention:
- k_ip, v_ip = map(
- lambda t: t.unsqueeze(3)
- .reshape(b, t.shape[1], self.heads, self.dim_head)
- .permute(0, 2, 1, 3)
- .reshape(b * self.heads, t.shape[1], self.dim_head)
- .contiguous(),
- (k_ip, v_ip),
- )
- out_ip = xformers.ops.memory_efficient_attention(q, k_ip, v_ip, attn_bias=None, op=None)
- out_ip = (
- out_ip.unsqueeze(0)
- .reshape(b, self.heads, out.shape[1], self.dim_head)
- .permute(0, 2, 1, 3)
- .reshape(b, out.shape[1], self.heads * self.dim_head)
- )
-
- if exists(mask):
- raise NotImplementedError
- out = (
- out.unsqueeze(0)
- .reshape(b, self.heads, out.shape[1], self.dim_head)
- .permute(0, 2, 1, 3)
- .reshape(b, out.shape[1], self.heads * self.dim_head)
- )
- if context is not None and self.img_cross_attention:
- out = out + self.image_cross_attention_scale * out_ip
- return self.to_out(out)
-
-
-class BasicTransformerBlock(nn.Module):
-
- def __init__(self, dim, n_heads, d_head, dropout=0., context_dim=None, gated_ff=True, checkpoint=True,
- disable_self_attn=False, attention_cls=None, img_cross_attention=False):
- super().__init__()
- attn_cls = CrossAttention if attention_cls is None else attention_cls
- self.disable_self_attn = disable_self_attn
- self.attn1 = attn_cls(query_dim=dim, heads=n_heads, dim_head=d_head, dropout=dropout,
- context_dim=context_dim if self.disable_self_attn else None)
- self.ff = FeedForward(dim, dropout=dropout, glu=gated_ff)
- self.attn2 = attn_cls(query_dim=dim, context_dim=context_dim, heads=n_heads, dim_head=d_head, dropout=dropout,
- img_cross_attention=img_cross_attention)
- self.norm1 = nn.LayerNorm(dim)
- self.norm2 = nn.LayerNorm(dim)
- self.norm3 = nn.LayerNorm(dim)
- self.checkpoint = checkpoint
-
- def forward(self, x, context=None, mask=None):
- ## implementation tricks: because checkpointing doesn't support non-tensor (e.g. None or scalar) arguments
- input_tuple = (x,) ## should not be (x), otherwise *input_tuple will decouple x into multiple arguments
- if context is not None:
- input_tuple = (x, context)
- if mask is not None:
- forward_mask = partial(self._forward, mask=mask)
- return checkpoint(forward_mask, (x,), self.parameters(), self.checkpoint)
- if context is not None and mask is not None:
- input_tuple = (x, context, mask)
- return checkpoint(self._forward, input_tuple, self.parameters(), self.checkpoint)
-
- def _forward(self, x, context=None, mask=None):
- x = self.attn1(self.norm1(x), context=context if self.disable_self_attn else None, mask=mask) + x
- x = self.attn2(self.norm2(x), context=context, mask=mask) + x
- x = self.ff(self.norm3(x)) + x
- return x
-
-
-class SpatialTransformer(nn.Module):
- """
- Transformer block for image-like data in spatial axis.
- First, project the input (aka embedding)
- and reshape to b, t, d.
- Then apply standard transformer action.
- Finally, reshape to image
- NEW: use_linear for more efficiency instead of the 1x1 convs
- """
-
- def __init__(self, in_channels, n_heads, d_head, depth=1, dropout=0., context_dim=None,
- use_checkpoint=True, disable_self_attn=False, use_linear=False, img_cross_attention=False):
- super().__init__()
- self.in_channels = in_channels
- inner_dim = n_heads * d_head
- self.norm = torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
- if not use_linear:
- self.proj_in = nn.Conv2d(in_channels, inner_dim, kernel_size=1, stride=1, padding=0)
- else:
- self.proj_in = nn.Linear(in_channels, inner_dim)
-
- self.transformer_blocks = nn.ModuleList([
- BasicTransformerBlock(
- inner_dim,
- n_heads,
- d_head,
- dropout=dropout,
- context_dim=context_dim,
- img_cross_attention=img_cross_attention,
- disable_self_attn=disable_self_attn,
- checkpoint=use_checkpoint) for d in range(depth)
- ])
- if not use_linear:
- self.proj_out = zero_module(nn.Conv2d(inner_dim, in_channels, kernel_size=1, stride=1, padding=0))
- else:
- self.proj_out = zero_module(nn.Linear(inner_dim, in_channels))
- self.use_linear = use_linear
-
-
- def forward(self, x, context=None):
- b, c, h, w = x.shape
- x_in = x
- x = self.norm(x)
- if not self.use_linear:
- x = self.proj_in(x)
- x = rearrange(x, 'b c h w -> b (h w) c').contiguous()
- if self.use_linear:
- x = self.proj_in(x)
- for i, block in enumerate(self.transformer_blocks):
- x = block(x, context=context)
- if self.use_linear:
- x = self.proj_out(x)
- x = rearrange(x, 'b (h w) c -> b c h w', h=h, w=w).contiguous()
- if not self.use_linear:
- x = self.proj_out(x)
- return x + x_in
-
-
-class TemporalTransformer(nn.Module):
- """
- Transformer block for image-like data in temporal axis.
- First, reshape to b, t, d.
- Then apply standard transformer action.
- Finally, reshape to image
- """
- def __init__(self, in_channels, n_heads, d_head, depth=1, dropout=0., context_dim=None,
- use_checkpoint=True, use_linear=False, only_self_att=True, causal_attention=False,
- relative_position=False, temporal_length=None):
- super().__init__()
- self.only_self_att = only_self_att
- self.relative_position = relative_position
- self.causal_attention = causal_attention
- self.in_channels = in_channels
- inner_dim = n_heads * d_head
- self.norm = torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
- self.proj_in = nn.Conv1d(in_channels, inner_dim, kernel_size=1, stride=1, padding=0)
- if not use_linear:
- self.proj_in = nn.Conv1d(in_channels, inner_dim, kernel_size=1, stride=1, padding=0)
- else:
- self.proj_in = nn.Linear(in_channels, inner_dim)
-
- if relative_position:
- assert(temporal_length is not None)
- attention_cls = partial(CrossAttention, relative_position=True, temporal_length=temporal_length)
- else:
- attention_cls = None
- if self.causal_attention:
- assert(temporal_length is not None)
- self.mask = torch.tril(torch.ones([1, temporal_length, temporal_length]))
-
- if self.only_self_att:
- context_dim = None
- self.transformer_blocks = nn.ModuleList([
- BasicTransformerBlock(
- inner_dim,
- n_heads,
- d_head,
- dropout=dropout,
- context_dim=context_dim,
- attention_cls=attention_cls,
- checkpoint=use_checkpoint) for d in range(depth)
- ])
- if not use_linear:
- self.proj_out = zero_module(nn.Conv1d(inner_dim, in_channels, kernel_size=1, stride=1, padding=0))
- else:
- self.proj_out = zero_module(nn.Linear(inner_dim, in_channels))
- self.use_linear = use_linear
-
- def forward(self, x, context=None):
- b, c, t, h, w = x.shape
- x_in = x
- x = self.norm(x)
- x = rearrange(x, 'b c t h w -> (b h w) c t').contiguous()
- if not self.use_linear:
- x = self.proj_in(x)
- x = rearrange(x, 'bhw c t -> bhw t c').contiguous()
- if self.use_linear:
- x = self.proj_in(x)
-
- if self.causal_attention:
- mask = self.mask.to(x.device)
- mask = repeat(mask, 'l i j -> (l bhw) i j', bhw=b*h*w)
- else:
- mask = None
-
- if self.only_self_att:
- ## note: if no context is given, cross-attention defaults to self-attention
- for i, block in enumerate(self.transformer_blocks):
- x = block(x, mask=mask)
- x = rearrange(x, '(b hw) t c -> b hw t c', b=b).contiguous()
- else:
- x = rearrange(x, '(b hw) t c -> b hw t c', b=b).contiguous()
- context = rearrange(context, '(b t) l con -> b t l con', t=t).contiguous()
- for i, block in enumerate(self.transformer_blocks):
- # calculate each batch one by one (since number in shape could not greater then 65,535 for some package)
- for j in range(b):
- context_j = repeat(
- context[j],
- 't l con -> (t r) l con', r=(h * w) // t, t=t).contiguous()
- ## note: causal mask will not applied in cross-attention case
- x[j] = block(x[j], context=context_j)
-
- if self.use_linear:
- x = self.proj_out(x)
- x = rearrange(x, 'b (h w) t c -> b c t h w', h=h, w=w).contiguous()
- if not self.use_linear:
- x = rearrange(x, 'b hw t c -> (b hw) c t').contiguous()
- x = self.proj_out(x)
- x = rearrange(x, '(b h w) c t -> b c t h w', b=b, h=h, w=w).contiguous()
-
- return x + x_in
-
-
-class GEGLU(nn.Module):
- def __init__(self, dim_in, dim_out):
- super().__init__()
- self.proj = nn.Linear(dim_in, dim_out * 2)
-
- def forward(self, x):
- x, gate = self.proj(x).chunk(2, dim=-1)
- return x * F.gelu(gate)
-
-
-class FeedForward(nn.Module):
- def __init__(self, dim, dim_out=None, mult=4, glu=False, dropout=0.):
- super().__init__()
- inner_dim = int(dim * mult)
- dim_out = default(dim_out, dim)
- project_in = nn.Sequential(
- nn.Linear(dim, inner_dim),
- nn.GELU()
- ) if not glu else GEGLU(dim, inner_dim)
-
- self.net = nn.Sequential(
- project_in,
- nn.Dropout(dropout),
- nn.Linear(inner_dim, dim_out)
- )
-
- def forward(self, x):
- return self.net(x)
-
-
-class LinearAttention(nn.Module):
- def __init__(self, dim, heads=4, dim_head=32):
- super().__init__()
- self.heads = heads
- hidden_dim = dim_head * heads
- self.to_qkv = nn.Conv2d(dim, hidden_dim * 3, 1, bias = False)
- self.to_out = nn.Conv2d(hidden_dim, dim, 1)
-
- def forward(self, x):
- b, c, h, w = x.shape
- qkv = self.to_qkv(x)
- q, k, v = rearrange(qkv, 'b (qkv heads c) h w -> qkv b heads c (h w)', heads = self.heads, qkv=3)
- k = k.softmax(dim=-1)
- context = torch.einsum('bhdn,bhen->bhde', k, v)
- out = torch.einsum('bhde,bhdn->bhen', context, q)
- out = rearrange(out, 'b heads c (h w) -> b (heads c) h w', heads=self.heads, h=h, w=w)
- return self.to_out(out)
-
-
-class SpatialSelfAttention(nn.Module):
- def __init__(self, in_channels):
- super().__init__()
- self.in_channels = in_channels
-
- self.norm = torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
- self.q = torch.nn.Conv2d(in_channels,
- in_channels,
- kernel_size=1,
- stride=1,
- padding=0)
- self.k = torch.nn.Conv2d(in_channels,
- in_channels,
- kernel_size=1,
- stride=1,
- padding=0)
- self.v = torch.nn.Conv2d(in_channels,
- in_channels,
- kernel_size=1,
- stride=1,
- padding=0)
- self.proj_out = torch.nn.Conv2d(in_channels,
- in_channels,
- kernel_size=1,
- stride=1,
- padding=0)
-
- def forward(self, x):
- h_ = x
- h_ = self.norm(h_)
- q = self.q(h_)
- k = self.k(h_)
- v = self.v(h_)
-
- # compute attention
- b,c,h,w = q.shape
- q = rearrange(q, 'b c h w -> b (h w) c')
- k = rearrange(k, 'b c h w -> b c (h w)')
- w_ = torch.einsum('bij,bjk->bik', q, k)
-
- w_ = w_ * (int(c)**(-0.5))
- w_ = torch.nn.functional.softmax(w_, dim=2)
-
- # attend to values
- v = rearrange(v, 'b c h w -> b c (h w)')
- w_ = rearrange(w_, 'b i j -> b j i')
- h_ = torch.einsum('bij,bjk->bik', v, w_)
- h_ = rearrange(h_, 'b c (h w) -> b c h w', h=h)
- h_ = self.proj_out(h_)
-
- return x+h_
diff --git a/spaces/Willow123/InternLM-XComposer/demo_asset/conversation.py b/spaces/Willow123/InternLM-XComposer/demo_asset/conversation.py
deleted file mode 100644
index ce285299a1281a93ff24a7226c101b5dd9ba75b9..0000000000000000000000000000000000000000
--- a/spaces/Willow123/InternLM-XComposer/demo_asset/conversation.py
+++ /dev/null
@@ -1,160 +0,0 @@
-from PIL import Image
-
-import torch
-from transformers import StoppingCriteria, StoppingCriteriaList
-
-import dataclasses
-from enum import auto, Enum
-from typing import List, Any
-
-
-class SeparatorStyle(Enum):
- """Different separator style."""
- SINGLE = auto()
- TWO = auto()
-
-
-@dataclasses.dataclass
-class Conversation:
- """A class that keeps all conversation history."""
- system: str
- roles: List[str]
- messages: List[List[str]]
- offset: int
- # system_img: List[Image.Image] = []
- sep_style: SeparatorStyle = SeparatorStyle.SINGLE
- sep: str = "###"
- sep2: str = None
-
- skip_next: bool = False
- conv_id: Any = None
-
- def get_prompt(self):
- if self.sep_style == SeparatorStyle.SINGLE:
- ret = self.system + self.sep
- for role, message in self.messages:
- if message:
- #ret += role + ": " + message + self.sep
- ret += role + ":" + message + self.sep
- else:
- ret += role + ":"
- return ret
- elif self.sep_style == SeparatorStyle.TWO:
- seps = [self.sep, self.sep2]
- ret = self.system + seps[0]
- for i, (role, message) in enumerate(self.messages):
- if message:
- ret += role + ": " + message[0] + seps[i % 2] if isinstance(message, list) else role + ": " + message + seps[i % 2]
- else:
- ret += role + ":"
- return ret
- elif self.sep_style == "7132":
- seps = [self.sep, self.sep2]
- ret = self.system
- for i, (role, message) in enumerate(self.messages):
- if message:
- ret += role + ": " + message[0] + seps[i % 2] if isinstance(message, list) else role + ": " + message + seps[i % 2]
- else:
- ret += role + ":"
- return ret
- elif self.sep_style == "raw":
- seps = [self.sep, self.sep2]
- ret = self.system
- for i, (role, message) in enumerate(self.messages):
- if message:
- ret += role + message + seps[i % 2]
- else:
- ret += role
- return ret
-
- else:
- raise ValueError(f"Invalid style: {self.sep_style}")
-
- def append_message(self, role, message):
- self.messages.append([role, message])
-
- def to_gradio_chatbot(self):
- ret = []
- for i, (role, msg) in enumerate(self.messages[self.offset:]):
- if i % 2 == 0:
- if type(msg) is tuple or type(msg) is list:
- import base64
- from io import BytesIO
- msg, image = msg
-
- max_hw, min_hw = max(image.size), min(image.size)
- aspect_ratio = max_hw / min_hw
- max_len, min_len = 800, 400
- shortest_edge = int(min(max_len / aspect_ratio, min_len, min_hw))
- longest_edge = int(shortest_edge * aspect_ratio)
- W, H = image.size
- if H > W:
- H, W = longest_edge, shortest_edge
- else:
- H, W = shortest_edge, longest_edge
- image = image.resize((W, H))
- # image = image.resize((224, 224))
- buffered = BytesIO()
- image.save(buffered, format="JPEG")
- img_b64_str = base64.b64encode(buffered.getvalue()).decode()
- img_str = f''
- msg = msg.replace(' Here's the new load parameter for your
"},function(e,t,n){"use strict";function o(e){return e&&e.__esModule?e:{"default":e}}t.__esModule=!0;var i=n(10),r=o(i),a=n(13),l=o(a),s=n(14),u=o(s),d=n(11),c=o(d),f=n(15),_=o(f),p=n(8),h=o(p),m=n(5),b=o(m),g=function(e,t){var n=e[t];return b["default"].isArray(arguments[2])||b["default"].isObject(arguments[2])?new r["default"](e,t,arguments[2]):b["default"].isNumber(n)?b["default"].isNumber(arguments[2])&&b["default"].isNumber(arguments[3])?b["default"].isNumber(arguments[4])?new u["default"](e,t,arguments[2],arguments[3],arguments[4]):new u["default"](e,t,arguments[2],arguments[3]):b["default"].isNumber(arguments[4])?new l["default"](e,t,{min:arguments[2],max:arguments[3],step:arguments[4]}):new l["default"](e,t,{min:arguments[2],max:arguments[3]}):b["default"].isString(n)?new c["default"](e,t):b["default"].isFunction(n)?new _["default"](e,t,""):b["default"].isBoolean(n)?new h["default"](e,t):null};t["default"]=g},function(e,t){"use strict";function n(e){setTimeout(e,1e3/60)}t.__esModule=!0,t["default"]=window.requestAnimationFrame||window.webkitRequestAnimationFrame||window.mozRequestAnimationFrame||window.oRequestAnimationFrame||window.msRequestAnimationFrame||n},function(e,t,n){"use strict";function o(e){return e&&e.__esModule?e:{"default":e}}function i(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}t.__esModule=!0;var r=n(9),a=o(r),l=n(5),s=o(l),u=function(){function e(){i(this,e),this.backgroundElement=document.createElement("div"),s["default"].extend(this.backgroundElement.style,{backgroundColor:"rgba(0,0,0,0.8)",top:0,left:0,display:"none",zIndex:"1000",opacity:0,WebkitTransition:"opacity 0.2s linear",transition:"opacity 0.2s linear"}),a["default"].makeFullscreen(this.backgroundElement),this.backgroundElement.style.position="fixed",this.domElement=document.createElement("div"),s["default"].extend(this.domElement.style,{position:"fixed",display:"none",zIndex:"1001",opacity:0,WebkitTransition:"-webkit-transform 0.2s ease-out, opacity 0.2s linear",transition:"transform 0.2s ease-out, opacity 0.2s linear"}),document.body.appendChild(this.backgroundElement),document.body.appendChild(this.domElement);var t=this;a["default"].bind(this.backgroundElement,"click",function(){t.hide()})}return e.prototype.show=function(){var e=this;this.backgroundElement.style.display="block",this.domElement.style.display="block",this.domElement.style.opacity=0,this.domElement.style.webkitTransform="scale(1.1)",this.layout(),s["default"].defer(function(){e.backgroundElement.style.opacity=1,e.domElement.style.opacity=1,e.domElement.style.webkitTransform="scale(1)"})},e.prototype.hide=function t(){var e=this,t=function n(){e.domElement.style.display="none",e.backgroundElement.style.display="none",a["default"].unbind(e.domElement,"webkitTransitionEnd",n),a["default"].unbind(e.domElement,"transitionend",n),a["default"].unbind(e.domElement,"oTransitionEnd",n)};a["default"].bind(this.domElement,"webkitTransitionEnd",t),a["default"].bind(this.domElement,"transitionend",t),a["default"].bind(this.domElement,"oTransitionEnd",t),this.backgroundElement.style.opacity=0,this.domElement.style.opacity=0,this.domElement.style.webkitTransform="scale(1.1)"},e.prototype.layout=function(){this.domElement.style.left=window.innerWidth/2-a["default"].getWidth(this.domElement)/2+"px",this.domElement.style.top=window.innerHeight/2-a["default"].getHeight(this.domElement)/2+"px"},e}();t["default"]=u},function(e,t,n){t=e.exports=n(24)(),t.push([e.id,".dg ul{list-style:none;margin:0;padding:0;width:100%;clear:both}.dg.ac{position:fixed;top:0;left:0;right:0;height:0;z-index:0}.dg:not(.ac) .main{overflow:hidden}.dg.main{-webkit-transition:opacity .1s linear;transition:opacity .1s linear}.dg.main.taller-than-window{overflow-y:auto}.dg.main.taller-than-window .close-button{opacity:1;margin-top:-1px;border-top:1px solid #2c2c2c}.dg.main ul.closed .close-button{opacity:1!important}.dg.main .close-button.drag,.dg.main:hover .close-button{opacity:1}.dg.main .close-button{-webkit-transition:opacity .1s linear;transition:opacity .1s linear;border:0;position:absolute;line-height:19px;height:20px;cursor:pointer;text-align:center;background-color:#000}.dg.main .close-button:hover{background-color:#111}.dg.a{float:right;margin-right:15px;overflow-x:hidden}.dg.a.has-save>ul{margin-top:27px}.dg.a.has-save>ul.closed{margin-top:0}.dg.a .save-row{position:fixed;top:0;z-index:1002}.dg li{-webkit-transition:height .1s ease-out;transition:height .1s ease-out}.dg li:not(.folder){cursor:auto;height:27px;line-height:27px;overflow:hidden;padding:0 4px 0 5px}.dg li.folder{padding:0;border-left:4px solid transparent}.dg li.title{cursor:pointer;margin-left:-4px}.dg .closed li:not(.title),.dg .closed ul li,.dg .closed ul li>*{height:0;overflow:hidden;border:0}.dg .cr{clear:both;padding-left:3px;height:27px}.dg .property-name{cursor:default;float:left;clear:left;width:40%;overflow:hidden;text-overflow:ellipsis}.dg .c{float:left;width:60%}.dg .c input[type=text]{border:0;margin-top:4px;padding:3px;width:100%;float:right}.dg .has-slider input[type=text]{width:30%;margin-left:0}.dg .slider{float:left;width:66%;margin-left:-5px;margin-right:0;height:19px;margin-top:4px}.dg .slider-fg{height:100%}.dg .c input[type=checkbox]{margin-top:9px}.dg .c select{margin-top:5px}.dg .cr.boolean,.dg .cr.boolean *,.dg .cr.function,.dg .cr.function *,.dg .cr.function .property-name{cursor:pointer}.dg .selector{display:none;position:absolute;margin-left:-9px;margin-top:23px;z-index:10}.dg .c:hover .selector,.dg .selector.drag{display:block}.dg li.save-row{padding:0}.dg li.save-row .button{display:inline-block;padding:0 6px}.dg.dialogue{background-color:#222;width:460px;padding:15px;font-size:13px;line-height:15px}#dg-new-constructor{padding:10px;color:#222;font-family:Monaco,monospace;font-size:10px;border:0;resize:none;box-shadow:inset 1px 1px 1px #888;word-wrap:break-word;margin:12px 0;display:block;width:440px;overflow-y:scroll;height:100px;position:relative}#dg-local-explain{display:none;font-size:11px;line-height:17px;border-radius:3px;background-color:#333;padding:8px;margin-top:10px}#dg-local-explain code{font-size:10px}#dat-gui-save-locally{display:none}.dg{color:#eee;font:11px Lucida Grande,sans-serif;text-shadow:0 -1px 0 #111}.dg.main::-webkit-scrollbar{width:5px;background:#1a1a1a}.dg.main::-webkit-scrollbar-corner{height:0;display:none}.dg.main::-webkit-scrollbar-thumb{border-radius:5px;background:#676767}.dg li:not(.folder){background:#1a1a1a;border-bottom:1px solid #2c2c2c}.dg li.save-row{line-height:25px;background:#dad5cb;border:0}.dg li.save-row select{margin-left:5px;width:108px}.dg li.save-row .button{margin-left:5px;margin-top:1px;border-radius:2px;font-size:9px;line-height:7px;padding:4px 4px 5px;background:#c5bdad;color:#fff;text-shadow:0 1px 0 #b0a58f;box-shadow:0 -1px 0 #b0a58f;cursor:pointer}.dg li.save-row .button.gears{background:#c5bdad url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAsAAAANCAYAAAB/9ZQ7AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAQJJREFUeNpiYKAU/P//PwGIC/ApCABiBSAW+I8AClAcgKxQ4T9hoMAEUrxx2QSGN6+egDX+/vWT4e7N82AMYoPAx/evwWoYoSYbACX2s7KxCxzcsezDh3evFoDEBYTEEqycggWAzA9AuUSQQgeYPa9fPv6/YWm/Acx5IPb7ty/fw+QZblw67vDs8R0YHyQhgObx+yAJkBqmG5dPPDh1aPOGR/eugW0G4vlIoTIfyFcA+QekhhHJhPdQxbiAIguMBTQZrPD7108M6roWYDFQiIAAv6Aow/1bFwXgis+f2LUAynwoIaNcz8XNx3Dl7MEJUDGQpx9gtQ8YCueB+D26OECAAQDadt7e46D42QAAAABJRU5ErkJggg==) 2px 1px no-repeat;height:7px;width:8px}.dg li.save-row .button:hover{background-color:#bab19e;box-shadow:0 -1px 0 #b0a58f}.dg li.folder{border-bottom:0}.dg li.title{padding-left:16px;background:#000 url(data:image/gif;base64,R0lGODlhBQAFAJEAAP////Pz8////////yH5BAEAAAIALAAAAAAFAAUAAAIIlI+hKgFxoCgAOw==) 6px 10px no-repeat;cursor:pointer;border-bottom:1px solid hsla(0,0%,100%,.2)}.dg .closed li.title{background-image:url(data:image/gif;base64,R0lGODlhBQAFAJEAAP////Pz8////////yH5BAEAAAIALAAAAAAFAAUAAAIIlGIWqMCbWAEAOw==)}.dg .cr.boolean{border-left:3px solid #806787}.dg .cr.color{border-left:3px solid}.dg .cr.function{border-left:3px solid #e61d5f}.dg .cr.number{border-left:3px solid #2fa1d6}.dg .cr.number input[type=text]{color:#2fa1d6}.dg .cr.string{border-left:3px solid #1ed36f}.dg .cr.string input[type=text]{color:#1ed36f}.dg .cr.boolean:hover,.dg .cr.function:hover{background:#111}.dg .c input[type=text]{background:#303030;outline:none}.dg .c input[type=text]:hover{background:#3c3c3c}.dg .c input[type=text]:focus{background:#494949;color:#fff}.dg .c .slider{background:#303030;cursor:ew-resize}.dg .c .slider-fg{background:#2fa1d6;max-width:100%}.dg .c .slider:hover{background:#3c3c3c}.dg .c .slider:hover .slider-fg{background:#44abda}",""])},function(e,t){e.exports=function(){var e=[];return e.toString=function(){for(var e=[],t=0;tGUI's constructor: Automatically save values to
localStorage on exit. The values saved to
localStorage will override those passed to dat.GUI's constructor. This makes it easier to work incrementally, but localStorage is fragile, and your friends may not see the same values you do. 13 things mentally strong people don't do pdf free download
DOWNLOAD ✸ https://urloso.com/2uyS93
- - aaccfb2cb3
-
-
- diff --git a/spaces/bioriAsaeru/text-to-voice/Aastha In The Prison Of Spring part 2 full movie online free - Rekha and Om Puris controversial role.md b/spaces/bioriAsaeru/text-to-voice/Aastha In The Prison Of Spring part 2 full movie online free - Rekha and Om Puris controversial role.md deleted file mode 100644 index ce6854f323c2e92624a9f67ec3923de66f61d6c7..0000000000000000000000000000000000000000 --- a/spaces/bioriAsaeru/text-to-voice/Aastha In The Prison Of Spring part 2 full movie online free - Rekha and Om Puris controversial role.md +++ /dev/null @@ -1,6 +0,0 @@ -
Aastha: In The Prison Of Spring part 2 full movie online free
DOWNLOAD ✒ https://urloso.com/2uyOAK
-
- aaccfb2cb3
-
-
- diff --git a/spaces/bioriAsaeru/text-to-voice/Brickhouse Betty Site Rip Extra Quality.md b/spaces/bioriAsaeru/text-to-voice/Brickhouse Betty Site Rip Extra Quality.md deleted file mode 100644 index 7d0c258a5dfa4444c214b673acdee49845f16a0c..0000000000000000000000000000000000000000 --- a/spaces/bioriAsaeru/text-to-voice/Brickhouse Betty Site Rip Extra Quality.md +++ /dev/null @@ -1,16 +0,0 @@ - -
170199 A.R.A. v. Commonwealth 03/01/2018 In a petition to expunge a felony arrest record, the trial court erred in concluding that the existence of this record may not cause the petitioner a manifest injustice. The facts underlying the arrest are irrelevant and the petitioner need not show actual prejudice to prevail on her expungement petition. She needs only to demonstrate that the continued existence of an arrest record may cause a manifest injustice. On this record, there is a reasonable possibility that a felony arrest record would hinder her career and her educational opportunities. It is concluded that the petitioner made the requisite showing of a manifest injustice. The judgment is reversed and the matter is remanded for entry of an order expunging the felony arrest record at issue.
-Brickhouse Betty Site Rip
Download ::: https://urloso.com/2uyPsb
-
101006 Livingston v. Va. Dep't of Transportation 06/07/2012 (Revised 08/02/2012) In a suit for property damage under the Just Compensation Clause in Article I, Section 11 of the Constitution of Virginia, it is held that a single event of flooding can support an inverse condemnation claim, and that the plaintiffs' allegations that their homes and various items of personal property were damaged for a public use under Article I, Section 11 are sufficient to withstand demurrer. When VDOT constructs an improvement for the public benefit, it does not thereby become an insurer in perpetuity against flood damage to neighboring property, but a property owner may be entitled to compensation under Article I, Section 11 if VDOT's operation of that improvement causes damage to real or personal property. Thus, where VDOT relocated the channel of a waterway in order to permit highway construction, but failed to maintain the relocated channel via dredging or otherwise, and that failure is alleged to have impacted the magnitude of the damage plaintiffs suffered as the result of the single flooding event at issue, VDOT's choice not to maintain the relocated channel evinced its election to use the highway and nearby residential developments as makeshift storage sites for excess stormwater instead of allocating its resources to maintain the relocated channel. The contentions that plaintiffs lack standing to maintain an inverse condemnation suit and that they cannot recover under Article I, Section 11 for damage to personal property, are rejected. The circuit court's judgment is reversed and the case is remanded for further proceedings.
-100149 Scott v. Burwell's Bay Improvement Ass'n 04/21/2011 In a case involving riparian rights, the circuit court did not err in ruling that a party seeking to establish ownership of riparian rights by adverse possession, or, alternately, a prescriptive easement to use those rights, failed to prove these claims by clear and convincing evidence. The evidence to show that the use of the riparian rights was exclusive and continuous for the required period of time fell well below the clear and convincing standard required to prove adverse possession or prescriptive use of the riparian rights by the immediate prior occupants. Thus tacking was not available to establish the requisite time periods. The judgment of the circuit court is affirmed.
-100303 Condominium Services v. First Owners' Ass'n 04/21/2011 (Revised 05/25/2011) In a lawsuit between a condominium owners' association and a management services company, the circuit court did not err in sustaining the association's demurrers and striking an affirmative defense. The agreement between the parties, although it referenced the association's bylaws, did not require a three-fourths vote of the unit owners before the association could terminate the services of the management agent. The circuit court also did not err in denying a motion to dismiss the association's conversion claim, because the agreement had been terminated at the time the management company caused over $90,000 in fees to be deposited to its own bank account, and it was not error to grant summary judgment on the conversion claim. Expert witness designations, testimony regarding damages, punitive damages and remittitur are also discussed. The judgment is affirmed.
- -091430 Commonwealth v. AMEC Civil 09/16/2010 In a construction contract dispute in which the plaintiff contractor and the defendant Virginia Department of Transportation both assign error, issues are discussed concerning timely notice of claims, whether sustained elevated lake water levels constitute a differing site condition under the contract, entitlement to home office overhead damages, calculation of actual costs as a basis for an award of damages, and entitlement to pre-judgment interest as an element of damages. The judgment of the Court of Appeals is affirmed in part and reversed in part, and the cases are remanded for the circuit court to recalculate damages.
-Bill was passionate about being active in the community he loved. In the past he served for eight years on the Middletown Town Council. He was the president of the Potter League for Animals, and was instrumental in its relocation to its present site. He served on the Boards of Newport Hospital, The Newport County YMCA, The Preservation Society of Newport County, The Rhode Island Foundation, and Newport Federal Savings Bank. He was actively involved in capital campaigns for The Maher Center and Newport Hospital. He was presently on the Board of Savings Institute Bank & Trust, was serving as legal counsel to The Newport County Chamber of Commerce, and was a member of the YMCA finance committee.
-Subject: Andrea
Date: Wed, 23 Jun 2004 16:40:27 -0400
From: "hannahrichard" hannahrichard@cox.net
To: Bryan@DenProductions.com
Dear Bryan,
One idea I had for the Great Bridge High School site was some sort of memorial for one of my friends,Andrea(rising sophomore)B. Deller, who passed away on June 19, 2004. I think it would be somethingthat many people would appreciate because so many of us were friends with her. In case you do notknow, the details are found below. Please consider this suggestion, because she meant so much tomany of us.
Yours sincerely,
Hannah Richard
Along with Andrea, our class has also lost two other people taken too soon, Miss April CarolynTownes and Mr Nicholas Stephen Rosso. Both were dear to our class and will be greatly missed duringour senior year. I'm sure many of their friends and family would appreciate their being added tothis site, because they are surely not forgotten.
Thanks,
Kate Welsh
Hi Bryan my name is Sarah Devincenzi Ferguson who was a drop out which i will advise no one to follow me in doing so. however Iwent to school with carole and knew her from the first grade. She always was a beautiful person inside and out. I still have a valentinecard that she gave me! I have cherished every memory of every one i have met . She was special and i hope she did well in her life.The card was signed "to my best friend ever!" well a lot of the past has changed but never the memories of all the nice people I met in school.I never remember bad things going on at great bridge high school in the 1960's. I went on to educate myself and I still am doing that.Stay in school kids even though I did not I am still married to the love of my life and it will be 52 years of ups and downs. I waslucky but not all are. So my advice is if you do not want to struggle through life get an education. Respect yourself and others. Thank you Bryan.
well wishes to all
Sarah D Ferguson
Hi Bryan. This is Sarah Ferguson again. My husband Jim Ferguson graduated from Great Bridge High in 1961. I recently replied to the request from CaroleSheltons family. Now I am told by Jim Ferguson that many of our classmates and neighbors have passed. I am so sad to hear that they had left us so earlyin their lives. Angela Sabato and I went to school together and were the quiet shy ones lol. Well I moved to sparrow road and met Jimmy who lived next door.We did not have to get married but back then it was a time when you had to move on and let your friends not be influenced by your actions. It was the bestof times when I knew all these nice people. Bryan do keep this site going. It helps us all to remember to reflect to pray and to realize that every secondon earth is precious and all of the young people on here seem to be very happy and doing well with their lives and I hope that life will continue to be precious to them.Thank you again Bryan and good luck to you also! Sincerely Sarah D Ferguson p.s. I did choose a very good man and life and I continued my education and Jim receivedhis masters degree from North Carolina State. Sometimes God has plans for us that we do not even know about.
Hello Bryan,
I came across your website whle doing an internet search on my Dads high school. His name was Lawrence Wayne Proctor,class of 1965 and passed away on August 26, 2011. If you would could you please include him on the "In Memoriam" page, thank you.
I do not have any high school pictures of him such as yearbook pictures or maybe some classmates have pictures with him. Could youpost a note on your website requesting of those who know my Dad to send me yearbook pictures etc they might have. Also, anyone thatmay have stories of my Dad they would like to share I would most interested to hear. My email is mwpphx@cox.net
Thank you,
Mark Proctor
Hi, I was looking up the name of one of my class mates Chris Ivey whom passed too soon. I notice that another studentthat we lost while in middle school that should of graduated with us ( CHRIS IVEY) and myself in 1993 was Vincent Mercerwas not on your page. I agree with whomever gave you the idea to start this page. These wonderful people were in our life'sand need to be remembered!!!!
Here are 2 pictures from my year book from 6th Grade.
Thanks
RIP VINCENT AND CHRIS you two are gone but NEVER NEVER forgotten!!!
I wrote you yesterday about adding Vincent Mercer whom I attended school with. I was looking on your website and didn't seeanother friend of mine that passed too soon. Warren T Trueblood Jr....He Graduated in 1989 from Great Bridge. His birthdayis May 24, 1970 and death date was Jan.14,1994- 23yrs old. He was like a brother to me, I was best friends growing upand still friends with his sister. Her daughter and my daughter/children have grown up together and it would be awesometo have him added to this board. He was a great, sweet, gentle person!!! I think of him often and all the times I sharedwith him and his sister. Well his whole family...Thank you for your time. God Bless.
Betty J Lewis-Kendrick CO 93 GBH
-
-
\ No newline at end of file diff --git a/spaces/bioriAsaeru/text-to-voice/Comsol Multiphysics 4.3 Crack _BEST_ License File Torrent. Process Titl.md b/spaces/bioriAsaeru/text-to-voice/Comsol Multiphysics 4.3 Crack _BEST_ License File Torrent. Process Titl.md deleted file mode 100644 index 7e213786920cdcb934ba674c6e8199b5124a0d28..0000000000000000000000000000000000000000 --- a/spaces/bioriAsaeru/text-to-voice/Comsol Multiphysics 4.3 Crack _BEST_ License File Torrent. Process Titl.md +++ /dev/null @@ -1,6 +0,0 @@ -
Comsol Multiphysics 4.3 Crack License File Torrent. process titl
Download ✓✓✓ https://urloso.com/2uyReH
-
- 4d29de3e1b
-
-
- diff --git a/spaces/bioriAsaeru/text-to-voice/Download Ccboot 2.1 Full Crack How to Install and Configure the Best Diskless Boot Solution.md b/spaces/bioriAsaeru/text-to-voice/Download Ccboot 2.1 Full Crack How to Install and Configure the Best Diskless Boot Solution.md deleted file mode 100644 index 14f413d5e80458b149d21cd2a53caea542a7642f..0000000000000000000000000000000000000000 --- a/spaces/bioriAsaeru/text-to-voice/Download Ccboot 2.1 Full Crack How to Install and Configure the Best Diskless Boot Solution.md +++ /dev/null @@ -1,6 +0,0 @@ -
Download Ccboot 2.1 Full Crack
DOWNLOAD 🗹 https://urloso.com/2uyOpg
-
- aaccfb2cb3
-
-
- diff --git a/spaces/bioriAsaeru/text-to-voice/Economics Lipsey And Chrystal 12th Edition Free Download98.md b/spaces/bioriAsaeru/text-to-voice/Economics Lipsey And Chrystal 12th Edition Free Download98.md deleted file mode 100644 index 914b414c3760fb266f80f0f68ce0e19d8bf6ec04..0000000000000000000000000000000000000000 --- a/spaces/bioriAsaeru/text-to-voice/Economics Lipsey And Chrystal 12th Edition Free Download98.md +++ /dev/null @@ -1,16 +0,0 @@ - -
How to Download Economics by Lipsey and Chrystal 12th Edition for Free
-Economics by Lipsey and Chrystal is a popular textbook that covers the essential principles and theory of microeconomics and macroeconomics. The 12th edition of this book was published in 2011 and provides a comprehensive and up-to-date review of the field. It also includes extensive practical applications and examples that help students understand the real-world relevance of the material.
-Economics Lipsey And Chrystal 12th Edition Free Download98
Download File --->>> https://urloso.com/2uyOqT
-
If you are looking for a free download of Economics by Lipsey and Chrystal 12th edition, you may have a hard time finding a legitimate and legal source. Many websites that claim to offer free downloads of this book are either scams, viruses, or infringe on the authors' copyrights. Therefore, you should be careful and avoid clicking on any suspicious links or downloading any files from unknown sources.
-One way to access Economics by Lipsey and Chrystal 12th edition for free is to use your library's online resources. Many libraries have subscriptions to e-book platforms that allow you to borrow or read digital copies of textbooks online. You can check your library's website or catalog to see if they have Economics by Lipsey and Chrystal 12th edition available as an e-book. If they do, you can use your library card number and password to access it.
-Another way to access Economics by Lipsey and Chrystal 12th edition for free is to use a reputable academic website that offers open access to textbooks. For example, you can try OpenStax, which is a non-profit organization that provides free, high-quality textbooks for various subjects. You can browse their catalog and see if they have a book that covers the same topics as Economics by Lipsey and Chrystal 12th edition. You can then download or read the book online for free.
-A third way to access Economics by Lipsey and Chrystal 12th edition for free is to use a peer-to-peer sharing platform that allows you to exchange files with other users. For example, you can try Library Genesis, which is a website that hosts millions of books, articles, and other documents. You can search for Economics by Lipsey and Chrystal 12th edition on their website and see if they have a PDF or EPUB file that you can download. However, you should be aware that this method may be illegal in some countries or regions, as it may violate the authors' intellectual property rights. Therefore, you should use this method at your own risk and discretion.
- -In conclusion, there are several ways to download Economics by Lipsey and Chrystal 12th edition for free, but not all of them are safe, legal, or ethical. You should always respect the authors' work and rights, and only use sources that are authorized or licensed to distribute their books. If you want to support the authors and publishers, you can also consider buying a copy of the book from a reputable online or offline bookstore.
- -Economics by Lipsey and Chrystal 12th edition is a comprehensive textbook that covers both microeconomics and macroeconomics. Microeconomics is the branch of economics that studies the behavior and decisions of individual agents, such as consumers, firms, and households. Macroeconomics is the branch of economics that studies the behavior and performance of the aggregate economy, such as national income, inflation, unemployment, and growth.
-The book is divided into six parts. The first part introduces the basic concepts and tools of economics, such as scarcity, opportunity cost, demand and supply, elasticity, and market equilibrium. The second part covers the theory of consumer behavior, production and costs, market structures, and market failure. The third part covers the measurement and determination of national income, aggregate demand and supply, money and banking, and inflation and unemployment. The fourth part covers the theory of economic growth, fiscal policy, monetary policy, and international trade and finance. The fifth part covers the issues and challenges of economic development, poverty and inequality, environmental economics, and public choice. The sixth part covers the history of economic thought, from Adam Smith to John Maynard Keynes.
-The book is written in a clear and engaging style, with numerous examples and applications from various countries and regions. It also includes graphs, tables, diagrams, boxes, summaries, exercises, and review questions to help students understand and apply the material. The book is suitable for undergraduate students who are taking introductory or intermediate courses in economics. It is also a useful reference for anyone who wants to learn more about the principles and practice of economics.
d5da3c52bf-
-
\ No newline at end of file diff --git a/spaces/bioriAsaeru/text-to-voice/Fundamentos De Fisica Frank Blatt.md b/spaces/bioriAsaeru/text-to-voice/Fundamentos De Fisica Frank Blatt.md deleted file mode 100644 index 10c0f9f7591631302dc81d4efaeade24f8c8fef3..0000000000000000000000000000000000000000 --- a/spaces/bioriAsaeru/text-to-voice/Fundamentos De Fisica Frank Blatt.md +++ /dev/null @@ -1,6 +0,0 @@ -
Fundamentos De Fisica Frank Blatt
Download Zip ✶✶✶ https://urloso.com/2uyQbm
-
-rel regulator dan motor power windows honda fundamentos de fisica para ... 64 Blatt Bedrucktes · Memo Guide De Biologie Et De Physiologie Humaines Ue 2 1 ... Elle Sappelait Anne Frank Lhistoire De La Femme Qui Aida La Famille Frank A ... 1fdad05405
-
-
- diff --git a/spaces/bla/tranny/App/Embedding/utils/Initialize.py b/spaces/bla/tranny/App/Embedding/utils/Initialize.py deleted file mode 100644 index 5420886869e95906bef34e737c435308b6f04f1f..0000000000000000000000000000000000000000 --- a/spaces/bla/tranny/App/Embedding/utils/Initialize.py +++ /dev/null @@ -1,66 +0,0 @@ -from langchain.embeddings import HuggingFaceEmbeddings -from langchain.docstore.document import Document -from langchain.vectorstores import Pinecone -import pinecone -import os - -# get api key from app.pinecone.io -PINECONE_API_KEY = os.environ.get("PINECONE_API_KEY") -# find your environment next to the api key in pinecone console -PINECONE_ENV = os.environ.get("PINECONE_ENVIRONMENT") - - -index_name = "transcript-bits" -model_name = "thenlper/gte-base" -embeddings = HuggingFaceEmbeddings(model_name=model_name) - - -pinecone.init(api_key=PINECONE_API_KEY, environment=PINECONE_ENV) -vector_index = pinecone.Index(index_name=index_name) -docsearch = Pinecone.from_existing_index(index_name, embeddings) - - -async def delete_documents(task_id): - docsearch.delete( - filter={ - "task_id": {"$eq": "task_id"}, - } - ) - - - -def generateChunks(chunks, task_id, n=100): - combined = [chunks[i : i + n] for i in range(0, len(chunks), n)] - result = [] - for chunk in combined: - data = {"text": ""} - for item in chunk: - if chunk.index(item) == 0: - data["start"] = item["start"] - if chunk.index(item) == len(chunk) - 1: - data["end"] = item["end"] - data["text"] += " " + item["text"] - - temp = Document( - page_content=data["text"], - metadata={"start": data["start"], "end": data["end"], "task_id": task_id}, - ) - result.append(temp) - return result - - -def search(query: str, task_id: str): - filtering_conditions = { - "task_id": {"$eq": "task_id"}, - } - data =docsearch.similarity_search(query, k=4, filter=filtering_conditions) - return [ - {"text": d.page_content, "start": d.metadata["start"], "end": d.metadata["end"]} - for d in data - ] - - - -def encode(temp: list[Document]): - docsearch.add_documents(temp) - # return embeddings.embed_documents(texts = [d.page_content for d in temp]) diff --git a/spaces/blmdsydm/faster-whisper-webui/app-shared.py b/spaces/blmdsydm/faster-whisper-webui/app-shared.py deleted file mode 100644 index 63cac1a8adaf90784c5f5f178f86243ad2149ee4..0000000000000000000000000000000000000000 --- a/spaces/blmdsydm/faster-whisper-webui/app-shared.py +++ /dev/null @@ -1,5 +0,0 @@ -# Run the app with no audio file restrictions -from app import create_ui -from src.config import ApplicationConfig - -create_ui(ApplicationConfig.create_default(input_audio_max_duration=-1, share=True)) \ No newline at end of file diff --git a/spaces/bunkalab/bunka-map/maps/violence_men_women.html b/spaces/bunkalab/bunka-map/maps/violence_men_women.html deleted file mode 100644 index 54d0f0198417c48d84a4978318cb81727ccbfcc2..0000000000000000000000000000000000000000 --- a/spaces/bunkalab/bunka-map/maps/violence_men_women.html +++ /dev/null @@ -1,14 +0,0 @@ - - - -
-
-
-
\ No newline at end of file
diff --git a/spaces/carlosalonso/Detection-video/carpeta_deteccion/tests/test_packaging.py b/spaces/carlosalonso/Detection-video/carpeta_deteccion/tests/test_packaging.py
deleted file mode 100644
index a5b1661e8f341fe66a6e02c59fe172bce445782b..0000000000000000000000000000000000000000
--- a/spaces/carlosalonso/Detection-video/carpeta_deteccion/tests/test_packaging.py
+++ /dev/null
@@ -1,24 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import unittest
-
-from detectron2.utils.collect_env import collect_env_info
-
-
-class TestProjects(unittest.TestCase):
- def test_import(self):
- from detectron2.projects import point_rend
-
- _ = point_rend.add_pointrend_config
-
- import detectron2.projects.deeplab as deeplab
-
- _ = deeplab.add_deeplab_config
-
- # import detectron2.projects.panoptic_deeplab as panoptic_deeplab
-
- # _ = panoptic_deeplab.add_panoptic_deeplab_config
-
-
-class TestCollectEnv(unittest.TestCase):
- def test(self):
- _ = collect_env_info()
diff --git a/spaces/carlosalonso/Detection-video/carpeta_deteccion/tools/deploy/README.md b/spaces/carlosalonso/Detection-video/carpeta_deteccion/tools/deploy/README.md
deleted file mode 100644
index e33cbeb54c003a5738da68c838fdaa4e0d218501..0000000000000000000000000000000000000000
--- a/spaces/carlosalonso/Detection-video/carpeta_deteccion/tools/deploy/README.md
+++ /dev/null
@@ -1,66 +0,0 @@
-See [deployment tutorial](https://detectron2.readthedocs.io/tutorials/deployment.html)
-for some high-level background about deployment.
-
-This directory contains the following examples:
-
-1. An example script `export_model.py`
- that exports a detectron2 model for deployment using different methods and formats.
-
-2. A C++ example that runs inference with Mask R-CNN model in TorchScript format.
-
-## Build
-Deployment depends on libtorch and OpenCV. Some require more dependencies:
-
-* Running TorchScript-format models produced by `--export-method=caffe2_tracing` requires libtorch
- to be built with caffe2 enabled.
-* Running TorchScript-format models produced by `--export-method=tracing/scripting` requires libtorchvision (C++ library of torchvision).
-
-All methods are supported in one C++ file that requires all the above dependencies.
-Adjust it and remove code you don't need.
-As a reference, we provide a [Dockerfile](../../docker/deploy.Dockerfile) that installs all the above dependencies and builds the C++ example.
-
-## Use
-
-We show a few example commands to export and execute a Mask R-CNN model in C++.
-
-* `export-method=tracing, format=torchscript`:
-```
-./export_model.py --config-file ../../configs/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml \
- --output ./output --export-method tracing --format torchscript \
- MODEL.WEIGHTS detectron2://COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x/137849600/model_final_f10217.pkl \
- MODEL.DEVICE cuda
-
-./build/torchscript_mask_rcnn output/model.ts input.jpg tracing
-```
-
-* `export-method=scripting, format=torchscript`:
-```
-./export_model.py --config-file ../../configs/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml \
- --output ./output --export-method scripting --format torchscript \
- MODEL.WEIGHTS detectron2://COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x/137849600/model_final_f10217.pkl \
-
-./build/torchscript_mask_rcnn output/model.ts input.jpg scripting
-```
-
-* `export-method=caffe2_tracing, format=torchscript`:
-
-```
-./export_model.py --config-file ../../configs/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml \
- --output ./output --export-method caffe2_tracing --format torchscript \
- MODEL.WEIGHTS detectron2://COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x/137849600/model_final_f10217.pkl \
-
-./build/torchscript_mask_rcnn output/model.ts input.jpg caffe2_tracing
-```
-
-
-## Notes:
-
-1. Tracing/Caffe2-tracing requires valid weights & sample inputs.
- Therefore the above commands require pre-trained models and [COCO dataset](https://detectron2.readthedocs.io/tutorials/builtin_datasets.html).
- You can modify the script to obtain sample inputs in other ways instead of from COCO.
-
-2. `--run-eval` is implemented only for tracing mode
- to evaluate the exported model using the dataset in the config.
- It's recommended to always verify the accuracy in case the conversion is not successful.
- Evaluation can be slow if model is exported to CPU or dataset is too large ("coco_2017_val_100" is a small subset of COCO useful for evaluation).
- `caffe2_tracing` accuracy may be slightly different (within 0.1 AP) from original model due to numerical precisions between different runtime.
diff --git a/spaces/chendl/compositional_test/transformers/src/transformers/models/albert/modeling_flax_albert.py b/spaces/chendl/compositional_test/transformers/src/transformers/models/albert/modeling_flax_albert.py
deleted file mode 100644
index 0ff1b9276a19d6a6ee101520f375a2af04a1defe..0000000000000000000000000000000000000000
--- a/spaces/chendl/compositional_test/transformers/src/transformers/models/albert/modeling_flax_albert.py
+++ /dev/null
@@ -1,1119 +0,0 @@
-# coding=utf-8
-# Copyright 2021 Google AI, Google Brain and the HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from typing import Callable, Optional, Tuple
-
-import flax
-import flax.linen as nn
-import jax
-import jax.numpy as jnp
-import numpy as np
-from flax.core.frozen_dict import FrozenDict, freeze, unfreeze
-from flax.linen.attention import dot_product_attention_weights
-from flax.traverse_util import flatten_dict, unflatten_dict
-from jax import lax
-
-from ...modeling_flax_outputs import (
- FlaxBaseModelOutput,
- FlaxBaseModelOutputWithPooling,
- FlaxMaskedLMOutput,
- FlaxMultipleChoiceModelOutput,
- FlaxQuestionAnsweringModelOutput,
- FlaxSequenceClassifierOutput,
- FlaxTokenClassifierOutput,
-)
-from ...modeling_flax_utils import (
- ACT2FN,
- FlaxPreTrainedModel,
- append_call_sample_docstring,
- append_replace_return_docstrings,
- overwrite_call_docstring,
-)
-from ...utils import ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward, logging
-from .configuration_albert import AlbertConfig
-
-
-logger = logging.get_logger(__name__)
-
-_CHECKPOINT_FOR_DOC = "albert-base-v2"
-_CONFIG_FOR_DOC = "AlbertConfig"
-
-
-@flax.struct.dataclass
-class FlaxAlbertForPreTrainingOutput(ModelOutput):
- """
- Output type of [`FlaxAlbertForPreTraining`].
-
- Args:
- prediction_logits (`jnp.ndarray` of shape `(batch_size, sequence_length, config.vocab_size)`):
- Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
- sop_logits (`jnp.ndarray` of shape `(batch_size, 2)`):
- Prediction scores of the next sequence prediction (classification) head (scores of True/False continuation
- before SoftMax).
- hidden_states (`tuple(jnp.ndarray)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
- Tuple of `jnp.ndarray` (one for the output of the embeddings + one for the output of each layer) of shape
- `(batch_size, sequence_length, hidden_size)`.
-
- Hidden-states of the model at the output of each layer plus the initial embedding outputs.
- attentions (`tuple(jnp.ndarray)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
- Tuple of `jnp.ndarray` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
- sequence_length)`.
-
- Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
- heads.
- """
-
- prediction_logits: jnp.ndarray = None
- sop_logits: jnp.ndarray = None
- hidden_states: Optional[Tuple[jnp.ndarray]] = None
- attentions: Optional[Tuple[jnp.ndarray]] = None
-
-
-ALBERT_START_DOCSTRING = r"""
-
- This model inherits from [`FlaxPreTrainedModel`]. Check the superclass documentation for the generic methods the
- library implements for all its model (such as downloading, saving and converting weights from PyTorch models)
-
- This model is also a Flax Linen [flax.linen.Module](https://flax.readthedocs.io/en/latest/flax.linen.html#module)
- subclass. Use it as a regular Flax linen Module and refer to the Flax documentation for all matter related to
- general usage and behavior.
-
- Finally, this model supports inherent JAX features such as:
-
- - [Just-In-Time (JIT) compilation](https://jax.readthedocs.io/en/latest/jax.html#just-in-time-compilation-jit)
- - [Automatic Differentiation](https://jax.readthedocs.io/en/latest/jax.html#automatic-differentiation)
- - [Vectorization](https://jax.readthedocs.io/en/latest/jax.html#vectorization-vmap)
- - [Parallelization](https://jax.readthedocs.io/en/latest/jax.html#parallelization-pmap)
-
- Parameters:
- config ([`AlbertConfig`]): Model configuration class with all the parameters of the model.
- Initializing with a config file does not load the weights associated with the model, only the
- configuration. Check out the [`~FlaxPreTrainedModel.from_pretrained`] method to load the model weights.
- dtype (`jax.numpy.dtype`, *optional*, defaults to `jax.numpy.float32`):
- The data type of the computation. Can be one of `jax.numpy.float32`, `jax.numpy.float16` (on GPUs) and
- `jax.numpy.bfloat16` (on TPUs).
-
- This can be used to enable mixed-precision training or half-precision inference on GPUs or TPUs. If
- specified all the computation will be performed with the given `dtype`.
-
- **Note that this only specifies the dtype of the computation and does not influence the dtype of model
- parameters.**
-
- If you wish to change the dtype of the model parameters, see [`~FlaxPreTrainedModel.to_fp16`] and
- [`~FlaxPreTrainedModel.to_bf16`].
-"""
-
-ALBERT_INPUTS_DOCSTRING = r"""
- Args:
- input_ids (`numpy.ndarray` of shape `({0})`):
- Indices of input sequence tokens in the vocabulary.
-
- Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
- [`PreTrainedTokenizer.__call__`] for details.
-
- [What are input IDs?](../glossary#input-ids)
- attention_mask (`numpy.ndarray` of shape `({0})`, *optional*):
- Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
-
- - 1 for tokens that are **not masked**,
- - 0 for tokens that are **masked**.
-
- [What are attention masks?](../glossary#attention-mask)
- token_type_ids (`numpy.ndarray` of shape `({0})`, *optional*):
- Segment token indices to indicate first and second portions of the inputs. Indices are selected in `[0,
- 1]`:
-
- - 0 corresponds to a *sentence A* token,
- - 1 corresponds to a *sentence B* token.
-
- [What are token type IDs?](../glossary#token-type-ids)
- position_ids (`numpy.ndarray` of shape `({0})`, *optional*):
- Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0,
- config.max_position_embeddings - 1]`.
- return_dict (`bool`, *optional*):
- Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
-
-"""
-
-
-class FlaxAlbertEmbeddings(nn.Module):
- """Construct the embeddings from word, position and token_type embeddings."""
-
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32 # the dtype of the computation
-
- def setup(self):
- self.word_embeddings = nn.Embed(
- self.config.vocab_size,
- self.config.embedding_size,
- embedding_init=jax.nn.initializers.normal(stddev=self.config.initializer_range),
- )
- self.position_embeddings = nn.Embed(
- self.config.max_position_embeddings,
- self.config.embedding_size,
- embedding_init=jax.nn.initializers.normal(stddev=self.config.initializer_range),
- )
- self.token_type_embeddings = nn.Embed(
- self.config.type_vocab_size,
- self.config.embedding_size,
- embedding_init=jax.nn.initializers.normal(stddev=self.config.initializer_range),
- )
- self.LayerNorm = nn.LayerNorm(epsilon=self.config.layer_norm_eps, dtype=self.dtype)
- self.dropout = nn.Dropout(rate=self.config.hidden_dropout_prob)
-
- # Copied from transformers.models.bert.modeling_flax_bert.FlaxBertEmbeddings.__call__
- def __call__(self, input_ids, token_type_ids, position_ids, deterministic: bool = True):
- # Embed
- inputs_embeds = self.word_embeddings(input_ids.astype("i4"))
- position_embeds = self.position_embeddings(position_ids.astype("i4"))
- token_type_embeddings = self.token_type_embeddings(token_type_ids.astype("i4"))
-
- # Sum all embeddings
- hidden_states = inputs_embeds + token_type_embeddings + position_embeds
-
- # Layer Norm
- hidden_states = self.LayerNorm(hidden_states)
- hidden_states = self.dropout(hidden_states, deterministic=deterministic)
- return hidden_states
-
-
-class FlaxAlbertSelfAttention(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32 # the dtype of the computation
-
- def setup(self):
- if self.config.hidden_size % self.config.num_attention_heads != 0:
- raise ValueError(
- "`config.hidden_size`: {self.config.hidden_size} has to be a multiple of `config.num_attention_heads` "
- " : {self.config.num_attention_heads}"
- )
-
- self.query = nn.Dense(
- self.config.hidden_size,
- dtype=self.dtype,
- kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
- )
- self.key = nn.Dense(
- self.config.hidden_size,
- dtype=self.dtype,
- kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
- )
- self.value = nn.Dense(
- self.config.hidden_size,
- dtype=self.dtype,
- kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
- )
- self.dense = nn.Dense(
- self.config.hidden_size,
- kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
- dtype=self.dtype,
- )
- self.LayerNorm = nn.LayerNorm(epsilon=self.config.layer_norm_eps, dtype=self.dtype)
- self.dropout = nn.Dropout(rate=self.config.hidden_dropout_prob)
-
- def __call__(self, hidden_states, attention_mask, deterministic=True, output_attentions: bool = False):
- head_dim = self.config.hidden_size // self.config.num_attention_heads
-
- query_states = self.query(hidden_states).reshape(
- hidden_states.shape[:2] + (self.config.num_attention_heads, head_dim)
- )
- value_states = self.value(hidden_states).reshape(
- hidden_states.shape[:2] + (self.config.num_attention_heads, head_dim)
- )
- key_states = self.key(hidden_states).reshape(
- hidden_states.shape[:2] + (self.config.num_attention_heads, head_dim)
- )
-
- # Convert the boolean attention mask to an attention bias.
- if attention_mask is not None:
- # attention mask in the form of attention bias
- attention_mask = jnp.expand_dims(attention_mask, axis=(-3, -2))
- attention_bias = lax.select(
- attention_mask > 0,
- jnp.full(attention_mask.shape, 0.0).astype(self.dtype),
- jnp.full(attention_mask.shape, jnp.finfo(self.dtype).min).astype(self.dtype),
- )
- else:
- attention_bias = None
-
- dropout_rng = None
- if not deterministic and self.config.attention_probs_dropout_prob > 0.0:
- dropout_rng = self.make_rng("dropout")
-
- attn_weights = dot_product_attention_weights(
- query_states,
- key_states,
- bias=attention_bias,
- dropout_rng=dropout_rng,
- dropout_rate=self.config.attention_probs_dropout_prob,
- broadcast_dropout=True,
- deterministic=deterministic,
- dtype=self.dtype,
- precision=None,
- )
-
- attn_output = jnp.einsum("...hqk,...khd->...qhd", attn_weights, value_states)
- attn_output = attn_output.reshape(attn_output.shape[:2] + (-1,))
-
- projected_attn_output = self.dense(attn_output)
- projected_attn_output = self.dropout(projected_attn_output, deterministic=deterministic)
- layernormed_attn_output = self.LayerNorm(projected_attn_output + hidden_states)
- outputs = (layernormed_attn_output, attn_weights) if output_attentions else (layernormed_attn_output,)
- return outputs
-
-
-class FlaxAlbertLayer(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32 # the dtype of the computation
-
- def setup(self):
- self.attention = FlaxAlbertSelfAttention(self.config, dtype=self.dtype)
- self.ffn = nn.Dense(
- self.config.intermediate_size,
- kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
- dtype=self.dtype,
- )
- self.activation = ACT2FN[self.config.hidden_act]
- self.ffn_output = nn.Dense(
- self.config.hidden_size,
- kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
- dtype=self.dtype,
- )
- self.full_layer_layer_norm = nn.LayerNorm(epsilon=self.config.layer_norm_eps, dtype=self.dtype)
- self.dropout = nn.Dropout(rate=self.config.hidden_dropout_prob)
-
- def __call__(
- self,
- hidden_states,
- attention_mask,
- deterministic: bool = True,
- output_attentions: bool = False,
- ):
- attention_outputs = self.attention(
- hidden_states, attention_mask, deterministic=deterministic, output_attentions=output_attentions
- )
- attention_output = attention_outputs[0]
- ffn_output = self.ffn(attention_output)
- ffn_output = self.activation(ffn_output)
- ffn_output = self.ffn_output(ffn_output)
- ffn_output = self.dropout(ffn_output, deterministic=deterministic)
- hidden_states = self.full_layer_layer_norm(ffn_output + attention_output)
-
- outputs = (hidden_states,)
-
- if output_attentions:
- outputs += (attention_outputs[1],)
- return outputs
-
-
-class FlaxAlbertLayerCollection(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32 # the dtype of the computation
-
- def setup(self):
- self.layers = [
- FlaxAlbertLayer(self.config, name=str(i), dtype=self.dtype) for i in range(self.config.inner_group_num)
- ]
-
- def __call__(
- self,
- hidden_states,
- attention_mask,
- deterministic: bool = True,
- output_attentions: bool = False,
- output_hidden_states: bool = False,
- ):
- layer_hidden_states = ()
- layer_attentions = ()
-
- for layer_index, albert_layer in enumerate(self.layers):
- layer_output = albert_layer(
- hidden_states,
- attention_mask,
- deterministic=deterministic,
- output_attentions=output_attentions,
- )
- hidden_states = layer_output[0]
-
- if output_attentions:
- layer_attentions = layer_attentions + (layer_output[1],)
-
- if output_hidden_states:
- layer_hidden_states = layer_hidden_states + (hidden_states,)
-
- outputs = (hidden_states,)
- if output_hidden_states:
- outputs = outputs + (layer_hidden_states,)
- if output_attentions:
- outputs = outputs + (layer_attentions,)
- return outputs # last-layer hidden state, (layer hidden states), (layer attentions)
-
-
-class FlaxAlbertLayerCollections(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32 # the dtype of the computation
- layer_index: Optional[str] = None
-
- def setup(self):
- self.albert_layers = FlaxAlbertLayerCollection(self.config, dtype=self.dtype)
-
- def __call__(
- self,
- hidden_states,
- attention_mask,
- deterministic: bool = True,
- output_attentions: bool = False,
- output_hidden_states: bool = False,
- ):
- outputs = self.albert_layers(
- hidden_states,
- attention_mask,
- deterministic=deterministic,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- )
- return outputs
-
-
-class FlaxAlbertLayerGroups(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32 # the dtype of the computation
-
- def setup(self):
- self.layers = [
- FlaxAlbertLayerCollections(self.config, name=str(i), layer_index=str(i), dtype=self.dtype)
- for i in range(self.config.num_hidden_groups)
- ]
-
- def __call__(
- self,
- hidden_states,
- attention_mask,
- deterministic: bool = True,
- output_attentions: bool = False,
- output_hidden_states: bool = False,
- return_dict: bool = True,
- ):
- all_attentions = () if output_attentions else None
- all_hidden_states = (hidden_states,) if output_hidden_states else None
-
- for i in range(self.config.num_hidden_layers):
- # Index of the hidden group
- group_idx = int(i / (self.config.num_hidden_layers / self.config.num_hidden_groups))
- layer_group_output = self.layers[group_idx](
- hidden_states,
- attention_mask,
- deterministic=deterministic,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- )
- hidden_states = layer_group_output[0]
-
- if output_attentions:
- all_attentions = all_attentions + layer_group_output[-1]
-
- if output_hidden_states:
- all_hidden_states = all_hidden_states + (hidden_states,)
-
- if not return_dict:
- return tuple(v for v in [hidden_states, all_hidden_states, all_attentions] if v is not None)
- return FlaxBaseModelOutput(
- last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_attentions
- )
-
-
-class FlaxAlbertEncoder(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32 # the dtype of the computation
-
- def setup(self):
- self.embedding_hidden_mapping_in = nn.Dense(
- self.config.hidden_size,
- kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
- dtype=self.dtype,
- )
- self.albert_layer_groups = FlaxAlbertLayerGroups(self.config, dtype=self.dtype)
-
- def __call__(
- self,
- hidden_states,
- attention_mask,
- deterministic: bool = True,
- output_attentions: bool = False,
- output_hidden_states: bool = False,
- return_dict: bool = True,
- ):
- hidden_states = self.embedding_hidden_mapping_in(hidden_states)
- return self.albert_layer_groups(
- hidden_states,
- attention_mask,
- deterministic=deterministic,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- )
-
-
-class FlaxAlbertOnlyMLMHead(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32
- bias_init: Callable[..., np.ndarray] = jax.nn.initializers.zeros
-
- def setup(self):
- self.dense = nn.Dense(self.config.embedding_size, dtype=self.dtype)
- self.activation = ACT2FN[self.config.hidden_act]
- self.LayerNorm = nn.LayerNorm(epsilon=self.config.layer_norm_eps, dtype=self.dtype)
- self.decoder = nn.Dense(self.config.vocab_size, dtype=self.dtype, use_bias=False)
- self.bias = self.param("bias", self.bias_init, (self.config.vocab_size,))
-
- def __call__(self, hidden_states, shared_embedding=None):
- hidden_states = self.dense(hidden_states)
- hidden_states = self.activation(hidden_states)
- hidden_states = self.LayerNorm(hidden_states)
-
- if shared_embedding is not None:
- hidden_states = self.decoder.apply({"params": {"kernel": shared_embedding.T}}, hidden_states)
- else:
- hidden_states = self.decoder(hidden_states)
-
- hidden_states += self.bias
- return hidden_states
-
-
-class FlaxAlbertSOPHead(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32
-
- def setup(self):
- self.dropout = nn.Dropout(self.config.classifier_dropout_prob)
- self.classifier = nn.Dense(2, dtype=self.dtype)
-
- def __call__(self, pooled_output, deterministic=True):
- pooled_output = self.dropout(pooled_output, deterministic=deterministic)
- logits = self.classifier(pooled_output)
- return logits
-
-
-class FlaxAlbertPreTrainedModel(FlaxPreTrainedModel):
- """
- An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
- models.
- """
-
- config_class = AlbertConfig
- base_model_prefix = "albert"
- module_class: nn.Module = None
-
- def __init__(
- self,
- config: AlbertConfig,
- input_shape: Tuple = (1, 1),
- seed: int = 0,
- dtype: jnp.dtype = jnp.float32,
- _do_init: bool = True,
- **kwargs,
- ):
- module = self.module_class(config=config, dtype=dtype, **kwargs)
- super().__init__(config, module, input_shape=input_shape, seed=seed, dtype=dtype, _do_init=_do_init)
-
- def init_weights(self, rng: jax.random.PRNGKey, input_shape: Tuple, params: FrozenDict = None) -> FrozenDict:
- # init input tensors
- input_ids = jnp.zeros(input_shape, dtype="i4")
- token_type_ids = jnp.zeros_like(input_ids)
- position_ids = jnp.broadcast_to(jnp.arange(jnp.atleast_2d(input_ids).shape[-1]), input_shape)
- attention_mask = jnp.ones_like(input_ids)
-
- params_rng, dropout_rng = jax.random.split(rng)
- rngs = {"params": params_rng, "dropout": dropout_rng}
-
- random_params = self.module.init(
- rngs, input_ids, attention_mask, token_type_ids, position_ids, return_dict=False
- )["params"]
-
- if params is not None:
- random_params = flatten_dict(unfreeze(random_params))
- params = flatten_dict(unfreeze(params))
- for missing_key in self._missing_keys:
- params[missing_key] = random_params[missing_key]
- self._missing_keys = set()
- return freeze(unflatten_dict(params))
- else:
- return random_params
-
- @add_start_docstrings_to_model_forward(ALBERT_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
- def __call__(
- self,
- input_ids,
- attention_mask=None,
- token_type_ids=None,
- position_ids=None,
- params: dict = None,
- dropout_rng: jax.random.PRNGKey = None,
- train: bool = False,
- output_attentions: Optional[bool] = None,
- output_hidden_states: Optional[bool] = None,
- return_dict: Optional[bool] = None,
- ):
- output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
- output_hidden_states = (
- output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
- )
- return_dict = return_dict if return_dict is not None else self.config.return_dict
-
- # init input tensors if not passed
- if token_type_ids is None:
- token_type_ids = jnp.zeros_like(input_ids)
-
- if position_ids is None:
- position_ids = jnp.broadcast_to(jnp.arange(jnp.atleast_2d(input_ids).shape[-1]), input_ids.shape)
-
- if attention_mask is None:
- attention_mask = jnp.ones_like(input_ids)
-
- # Handle any PRNG if needed
- rngs = {}
- if dropout_rng is not None:
- rngs["dropout"] = dropout_rng
-
- return self.module.apply(
- {"params": params or self.params},
- jnp.array(input_ids, dtype="i4"),
- jnp.array(attention_mask, dtype="i4"),
- jnp.array(token_type_ids, dtype="i4"),
- jnp.array(position_ids, dtype="i4"),
- not train,
- output_attentions,
- output_hidden_states,
- return_dict,
- rngs=rngs,
- )
-
-
-class FlaxAlbertModule(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32 # the dtype of the computation
- add_pooling_layer: bool = True
-
- def setup(self):
- self.embeddings = FlaxAlbertEmbeddings(self.config, dtype=self.dtype)
- self.encoder = FlaxAlbertEncoder(self.config, dtype=self.dtype)
- if self.add_pooling_layer:
- self.pooler = nn.Dense(
- self.config.hidden_size,
- kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
- dtype=self.dtype,
- name="pooler",
- )
- self.pooler_activation = nn.tanh
- else:
- self.pooler = None
- self.pooler_activation = None
-
- def __call__(
- self,
- input_ids,
- attention_mask,
- token_type_ids: Optional[np.ndarray] = None,
- position_ids: Optional[np.ndarray] = None,
- deterministic: bool = True,
- output_attentions: bool = False,
- output_hidden_states: bool = False,
- return_dict: bool = True,
- ):
- # make sure `token_type_ids` is correctly initialized when not passed
- if token_type_ids is None:
- token_type_ids = jnp.zeros_like(input_ids)
-
- # make sure `position_ids` is correctly initialized when not passed
- if position_ids is None:
- position_ids = jnp.broadcast_to(jnp.arange(jnp.atleast_2d(input_ids).shape[-1]), input_ids.shape)
-
- hidden_states = self.embeddings(input_ids, token_type_ids, position_ids, deterministic=deterministic)
-
- outputs = self.encoder(
- hidden_states,
- attention_mask,
- deterministic=deterministic,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
- hidden_states = outputs[0]
- if self.add_pooling_layer:
- pooled = self.pooler(hidden_states[:, 0])
- pooled = self.pooler_activation(pooled)
- else:
- pooled = None
-
- if not return_dict:
- # if pooled is None, don't return it
- if pooled is None:
- return (hidden_states,) + outputs[1:]
- return (hidden_states, pooled) + outputs[1:]
-
- return FlaxBaseModelOutputWithPooling(
- last_hidden_state=hidden_states,
- pooler_output=pooled,
- hidden_states=outputs.hidden_states,
- attentions=outputs.attentions,
- )
-
-
-@add_start_docstrings(
- "The bare Albert Model transformer outputting raw hidden-states without any specific head on top.",
- ALBERT_START_DOCSTRING,
-)
-class FlaxAlbertModel(FlaxAlbertPreTrainedModel):
- module_class = FlaxAlbertModule
-
-
-append_call_sample_docstring(FlaxAlbertModel, _CHECKPOINT_FOR_DOC, FlaxBaseModelOutputWithPooling, _CONFIG_FOR_DOC)
-
-
-class FlaxAlbertForPreTrainingModule(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32
-
- def setup(self):
- self.albert = FlaxAlbertModule(config=self.config, dtype=self.dtype)
- self.predictions = FlaxAlbertOnlyMLMHead(config=self.config, dtype=self.dtype)
- self.sop_classifier = FlaxAlbertSOPHead(config=self.config, dtype=self.dtype)
-
- def __call__(
- self,
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic: bool = True,
- output_attentions: bool = False,
- output_hidden_states: bool = False,
- return_dict: bool = True,
- ):
- # Model
- outputs = self.albert(
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic=deterministic,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
-
- if self.config.tie_word_embeddings:
- shared_embedding = self.albert.variables["params"]["embeddings"]["word_embeddings"]["embedding"]
- else:
- shared_embedding = None
-
- hidden_states = outputs[0]
- pooled_output = outputs[1]
-
- prediction_scores = self.predictions(hidden_states, shared_embedding=shared_embedding)
- sop_scores = self.sop_classifier(pooled_output, deterministic=deterministic)
-
- if not return_dict:
- return (prediction_scores, sop_scores) + outputs[2:]
-
- return FlaxAlbertForPreTrainingOutput(
- prediction_logits=prediction_scores,
- sop_logits=sop_scores,
- hidden_states=outputs.hidden_states,
- attentions=outputs.attentions,
- )
-
-
-@add_start_docstrings(
- """
- Albert Model with two heads on top as done during the pretraining: a `masked language modeling` head and a
- `sentence order prediction (classification)` head.
- """,
- ALBERT_START_DOCSTRING,
-)
-class FlaxAlbertForPreTraining(FlaxAlbertPreTrainedModel):
- module_class = FlaxAlbertForPreTrainingModule
-
-
-FLAX_ALBERT_FOR_PRETRAINING_DOCSTRING = """
- Returns:
-
- Example:
-
- ```python
- >>> from transformers import AutoTokenizer, FlaxAlbertForPreTraining
-
- >>> tokenizer = AutoTokenizer.from_pretrained("albert-base-v2")
- >>> model = FlaxAlbertForPreTraining.from_pretrained("albert-base-v2")
-
- >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="np")
- >>> outputs = model(**inputs)
-
- >>> prediction_logits = outputs.prediction_logits
- >>> seq_relationship_logits = outputs.sop_logits
- ```
-"""
-
-overwrite_call_docstring(
- FlaxAlbertForPreTraining,
- ALBERT_INPUTS_DOCSTRING.format("batch_size, sequence_length") + FLAX_ALBERT_FOR_PRETRAINING_DOCSTRING,
-)
-append_replace_return_docstrings(
- FlaxAlbertForPreTraining, output_type=FlaxAlbertForPreTrainingOutput, config_class=_CONFIG_FOR_DOC
-)
-
-
-class FlaxAlbertForMaskedLMModule(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32
-
- def setup(self):
- self.albert = FlaxAlbertModule(config=self.config, add_pooling_layer=False, dtype=self.dtype)
- self.predictions = FlaxAlbertOnlyMLMHead(config=self.config, dtype=self.dtype)
-
- def __call__(
- self,
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic: bool = True,
- output_attentions: bool = False,
- output_hidden_states: bool = False,
- return_dict: bool = True,
- ):
- # Model
- outputs = self.albert(
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic=deterministic,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
-
- hidden_states = outputs[0]
- if self.config.tie_word_embeddings:
- shared_embedding = self.albert.variables["params"]["embeddings"]["word_embeddings"]["embedding"]
- else:
- shared_embedding = None
-
- # Compute the prediction scores
- logits = self.predictions(hidden_states, shared_embedding=shared_embedding)
-
- if not return_dict:
- return (logits,) + outputs[1:]
-
- return FlaxMaskedLMOutput(
- logits=logits,
- hidden_states=outputs.hidden_states,
- attentions=outputs.attentions,
- )
-
-
-@add_start_docstrings("""Albert Model with a `language modeling` head on top.""", ALBERT_START_DOCSTRING)
-class FlaxAlbertForMaskedLM(FlaxAlbertPreTrainedModel):
- module_class = FlaxAlbertForMaskedLMModule
-
-
-append_call_sample_docstring(FlaxAlbertForMaskedLM, _CHECKPOINT_FOR_DOC, FlaxMaskedLMOutput, _CONFIG_FOR_DOC)
-
-
-class FlaxAlbertForSequenceClassificationModule(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32
-
- def setup(self):
- self.albert = FlaxAlbertModule(config=self.config, dtype=self.dtype)
- classifier_dropout = (
- self.config.classifier_dropout_prob
- if self.config.classifier_dropout_prob is not None
- else self.config.hidden_dropout_prob
- )
- self.dropout = nn.Dropout(rate=classifier_dropout)
- self.classifier = nn.Dense(
- self.config.num_labels,
- dtype=self.dtype,
- )
-
- def __call__(
- self,
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic: bool = True,
- output_attentions: bool = False,
- output_hidden_states: bool = False,
- return_dict: bool = True,
- ):
- # Model
- outputs = self.albert(
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic=deterministic,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
-
- pooled_output = outputs[1]
- pooled_output = self.dropout(pooled_output, deterministic=deterministic)
- logits = self.classifier(pooled_output)
-
- if not return_dict:
- return (logits,) + outputs[2:]
-
- return FlaxSequenceClassifierOutput(
- logits=logits,
- hidden_states=outputs.hidden_states,
- attentions=outputs.attentions,
- )
-
-
-@add_start_docstrings(
- """
- Albert Model transformer with a sequence classification/regression head on top (a linear layer on top of the pooled
- output) e.g. for GLUE tasks.
- """,
- ALBERT_START_DOCSTRING,
-)
-class FlaxAlbertForSequenceClassification(FlaxAlbertPreTrainedModel):
- module_class = FlaxAlbertForSequenceClassificationModule
-
-
-append_call_sample_docstring(
- FlaxAlbertForSequenceClassification,
- _CHECKPOINT_FOR_DOC,
- FlaxSequenceClassifierOutput,
- _CONFIG_FOR_DOC,
-)
-
-
-class FlaxAlbertForMultipleChoiceModule(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32
-
- def setup(self):
- self.albert = FlaxAlbertModule(config=self.config, dtype=self.dtype)
- self.dropout = nn.Dropout(rate=self.config.hidden_dropout_prob)
- self.classifier = nn.Dense(1, dtype=self.dtype)
-
- def __call__(
- self,
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic: bool = True,
- output_attentions: bool = False,
- output_hidden_states: bool = False,
- return_dict: bool = True,
- ):
- num_choices = input_ids.shape[1]
- input_ids = input_ids.reshape(-1, input_ids.shape[-1]) if input_ids is not None else None
- attention_mask = attention_mask.reshape(-1, attention_mask.shape[-1]) if attention_mask is not None else None
- token_type_ids = token_type_ids.reshape(-1, token_type_ids.shape[-1]) if token_type_ids is not None else None
- position_ids = position_ids.reshape(-1, position_ids.shape[-1]) if position_ids is not None else None
-
- # Model
- outputs = self.albert(
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic=deterministic,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
-
- pooled_output = outputs[1]
- pooled_output = self.dropout(pooled_output, deterministic=deterministic)
- logits = self.classifier(pooled_output)
-
- reshaped_logits = logits.reshape(-1, num_choices)
-
- if not return_dict:
- return (reshaped_logits,) + outputs[2:]
-
- return FlaxMultipleChoiceModelOutput(
- logits=reshaped_logits,
- hidden_states=outputs.hidden_states,
- attentions=outputs.attentions,
- )
-
-
-@add_start_docstrings(
- """
- Albert Model with a multiple choice classification head on top (a linear layer on top of the pooled output and a
- softmax) e.g. for RocStories/SWAG tasks.
- """,
- ALBERT_START_DOCSTRING,
-)
-class FlaxAlbertForMultipleChoice(FlaxAlbertPreTrainedModel):
- module_class = FlaxAlbertForMultipleChoiceModule
-
-
-overwrite_call_docstring(
- FlaxAlbertForMultipleChoice, ALBERT_INPUTS_DOCSTRING.format("batch_size, num_choices, sequence_length")
-)
-append_call_sample_docstring(
- FlaxAlbertForMultipleChoice,
- _CHECKPOINT_FOR_DOC,
- FlaxMultipleChoiceModelOutput,
- _CONFIG_FOR_DOC,
-)
-
-
-class FlaxAlbertForTokenClassificationModule(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32
-
- def setup(self):
- self.albert = FlaxAlbertModule(config=self.config, dtype=self.dtype, add_pooling_layer=False)
- classifier_dropout = (
- self.config.classifier_dropout_prob
- if self.config.classifier_dropout_prob is not None
- else self.config.hidden_dropout_prob
- )
- self.dropout = nn.Dropout(rate=classifier_dropout)
- self.classifier = nn.Dense(self.config.num_labels, dtype=self.dtype)
-
- def __call__(
- self,
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic: bool = True,
- output_attentions: bool = False,
- output_hidden_states: bool = False,
- return_dict: bool = True,
- ):
- # Model
- outputs = self.albert(
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic=deterministic,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
-
- hidden_states = outputs[0]
- hidden_states = self.dropout(hidden_states, deterministic=deterministic)
- logits = self.classifier(hidden_states)
-
- if not return_dict:
- return (logits,) + outputs[1:]
-
- return FlaxTokenClassifierOutput(
- logits=logits,
- hidden_states=outputs.hidden_states,
- attentions=outputs.attentions,
- )
-
-
-@add_start_docstrings(
- """
- Albert Model with a token classification head on top (a linear layer on top of the hidden-states output) e.g. for
- Named-Entity-Recognition (NER) tasks.
- """,
- ALBERT_START_DOCSTRING,
-)
-class FlaxAlbertForTokenClassification(FlaxAlbertPreTrainedModel):
- module_class = FlaxAlbertForTokenClassificationModule
-
-
-append_call_sample_docstring(
- FlaxAlbertForTokenClassification,
- _CHECKPOINT_FOR_DOC,
- FlaxTokenClassifierOutput,
- _CONFIG_FOR_DOC,
-)
-
-
-class FlaxAlbertForQuestionAnsweringModule(nn.Module):
- config: AlbertConfig
- dtype: jnp.dtype = jnp.float32
-
- def setup(self):
- self.albert = FlaxAlbertModule(config=self.config, dtype=self.dtype, add_pooling_layer=False)
- self.qa_outputs = nn.Dense(self.config.num_labels, dtype=self.dtype)
-
- def __call__(
- self,
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic: bool = True,
- output_attentions: bool = False,
- output_hidden_states: bool = False,
- return_dict: bool = True,
- ):
- # Model
- outputs = self.albert(
- input_ids,
- attention_mask,
- token_type_ids,
- position_ids,
- deterministic=deterministic,
- output_attentions=output_attentions,
- output_hidden_states=output_hidden_states,
- return_dict=return_dict,
- )
-
- hidden_states = outputs[0]
-
- logits = self.qa_outputs(hidden_states)
- start_logits, end_logits = logits.split(self.config.num_labels, axis=-1)
- start_logits = start_logits.squeeze(-1)
- end_logits = end_logits.squeeze(-1)
-
- if not return_dict:
- return (start_logits, end_logits) + outputs[1:]
-
- return FlaxQuestionAnsweringModelOutput(
- start_logits=start_logits,
- end_logits=end_logits,
- hidden_states=outputs.hidden_states,
- attentions=outputs.attentions,
- )
-
-
-@add_start_docstrings(
- """
- Albert Model with a span classification head on top for extractive question-answering tasks like SQuAD (a linear
- layers on top of the hidden-states output to compute `span start logits` and `span end logits`).
- """,
- ALBERT_START_DOCSTRING,
-)
-class FlaxAlbertForQuestionAnswering(FlaxAlbertPreTrainedModel):
- module_class = FlaxAlbertForQuestionAnsweringModule
-
-
-append_call_sample_docstring(
- FlaxAlbertForQuestionAnswering,
- _CHECKPOINT_FOR_DOC,
- FlaxQuestionAnsweringModelOutput,
- _CONFIG_FOR_DOC,
-)
diff --git a/spaces/chenyangqi/FateZero/FateZero/video_diffusion/pipelines/DDIMSpatioTemporalStableDiffusionPipeline.py b/spaces/chenyangqi/FateZero/FateZero/video_diffusion/pipelines/DDIMSpatioTemporalStableDiffusionPipeline.py
deleted file mode 100644
index 5228dfa27bdf54081b9a075f3d4d7ea7a437d42f..0000000000000000000000000000000000000000
--- a/spaces/chenyangqi/FateZero/FateZero/video_diffusion/pipelines/DDIMSpatioTemporalStableDiffusionPipeline.py
+++ /dev/null
@@ -1,300 +0,0 @@
-# code mostly taken from https://github.com/huggingface/diffusers
-import inspect
-from typing import Callable, List, Optional, Union
-import PIL
-import torch
-import numpy as np
-from einops import rearrange
-from tqdm import trange, tqdm
-
-from diffusers.utils import deprecate, logging
-from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
-
-from ..models.unet_3d_condition import UNetPseudo3DConditionModel
-from .stable_diffusion import SpatioTemporalStableDiffusionPipeline
-
-logger = logging.get_logger(__name__) # pylint: disable=invalid-name
-
-
-class DDIMSpatioTemporalStableDiffusionPipeline(SpatioTemporalStableDiffusionPipeline):
- r"""
- Pipeline for text-to-video generation using Spatio-Temporal Stable Diffusion.
- """
-
- def check_inputs(self, prompt, height, width, callback_steps, strength=None):
- if not isinstance(prompt, str) and not isinstance(prompt, list):
- raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
- if strength is not None:
- if strength <= 0 or strength > 1:
- raise ValueError(f"The value of strength should in (0.0, 1.0] but is {strength}")
-
- if height % 8 != 0 or width % 8 != 0:
- raise ValueError(
- f"`height` and `width` have to be divisible by 8 but are {height} and {width}."
- )
-
- if (callback_steps is None) or (
- callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0)
- ):
- raise ValueError(
- f"`callback_steps` has to be a positive integer but is {callback_steps} of type"
- f" {type(callback_steps)}."
- )
-
-
-
- def prepare_latents_ddim_inverted(self, image, batch_size, num_images_per_prompt,
- # dtype, device,
- text_embeddings,
- generator=None):
-
- # Not sure if image need to change device and type
- # image = image.to(device=device, dtype=dtype)
-
- batch_size = batch_size * num_images_per_prompt
- if isinstance(generator, list) and len(generator) != batch_size:
- raise ValueError(
- f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
- f" size of {batch_size}. Make sure the batch size matches the length of the generators."
- )
-
- if isinstance(generator, list):
- init_latents = [
- self.vae.encode(image[i : i + 1]).latent_dist.sample(generator[i]) for i in range(batch_size)
- ]
- init_latents = torch.cat(init_latents, dim=0)
- else:
- init_latents = self.vae.encode(image).latent_dist.sample(generator)
- init_latents = 0.18215 * init_latents
-
- if batch_size > init_latents.shape[0] and batch_size % init_latents.shape[0] == 0:
- # expand init_latents for batch_size
- deprecation_message = (
- f"You have passed {batch_size} text prompts (`prompt`), but only {init_latents.shape[0]} initial"
- " images (`image`). Initial images are now duplicating to match the number of text prompts. Note"
- " that this behavior is deprecated and will be removed in a version 1.0.0. Please make sure to update"
- " your script to pass as many initial images as text prompts to suppress this warning."
- )
- deprecate("len(prompt) != len(image)", "1.0.0", deprecation_message, standard_warn=False)
- additional_image_per_prompt = batch_size // init_latents.shape[0]
- init_latents = torch.cat([init_latents] * additional_image_per_prompt, dim=0)
- elif batch_size > init_latents.shape[0] and batch_size % init_latents.shape[0] != 0:
- raise ValueError(
- f"Cannot duplicate `image` of batch size {init_latents.shape[0]} to {batch_size} text prompts."
- )
- else:
- init_latents = torch.cat([init_latents], dim=0)
-
- # get latents
- init_latents_bcfhw = rearrange(init_latents, "(b f) c h w -> b c f h w", b=batch_size)
- ddim_latents_all_step = self.ddim_clean2noisy_loop(init_latents_bcfhw, text_embeddings)
- return ddim_latents_all_step
-
- @torch.no_grad()
- def ddim_clean2noisy_loop(self, latent, text_embeddings):
- weight_dtype = latent.dtype
- uncond_embeddings, cond_embeddings = text_embeddings.chunk(2)
- all_latent = [latent]
- latent = latent.clone().detach()
- print(' Invert clean image to noise latents by DDIM and Unet')
- for i in trange(len(self.scheduler.timesteps)):
- t = self.scheduler.timesteps[len(self.scheduler.timesteps) - i - 1]
- # noise_pred = self.get_noise_pred_single(latent, t, cond_embeddings)
- noise_pred = self.unet(latent, t, encoder_hidden_states=cond_embeddings)["sample"] # [1, 4, 8, 64, 64] -> [1, 4, 8, 64, 64])
- latent = self.next_clean2noise_step(noise_pred, t, latent)
- all_latent.append(latent.to(dtype=weight_dtype))
-
- return all_latent
-
- def next_clean2noise_step(self, model_output: Union[torch.FloatTensor, np.ndarray], timestep: int, sample: Union[torch.FloatTensor, np.ndarray]):
- """
- Assume the eta in DDIM=0
- """
- timestep, next_timestep = min(timestep - self.scheduler.config.num_train_timesteps // self.scheduler.num_inference_steps, 999), timestep
- alpha_prod_t = self.scheduler.alphas_cumprod[timestep] if timestep >= 0 else self.scheduler.final_alpha_cumprod
- alpha_prod_t_next = self.scheduler.alphas_cumprod[next_timestep]
- beta_prod_t = 1 - alpha_prod_t
- next_original_sample = (sample - beta_prod_t ** 0.5 * model_output) / alpha_prod_t ** 0.5
- next_sample_direction = (1 - alpha_prod_t_next) ** 0.5 * model_output
- next_sample = alpha_prod_t_next ** 0.5 * next_original_sample + next_sample_direction
- return next_sample
-
- def get_timesteps(self, num_inference_steps, strength, device):
- # get the original timestep using init_timestep
- init_timestep = min(int(num_inference_steps * strength), num_inference_steps)
-
- t_start = max(num_inference_steps - init_timestep, 0)
- timesteps = self.scheduler.timesteps[t_start:]
-
- return timesteps, num_inference_steps - t_start
-
- @torch.no_grad()
- def __call__(
- self,
- prompt: Union[str, List[str]],
- image: Union[torch.FloatTensor, PIL.Image.Image] = None,
- height: Optional[int] = None,
- width: Optional[int] = None,
- strength: float = None,
- num_inference_steps: int = 50,
- clip_length: int = 8,
- guidance_scale: float = 7.5,
- negative_prompt: Optional[Union[str, List[str]]] = None,
- num_images_per_prompt: Optional[int] = 1,
- eta: float = 0.0,
- generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
- latents: Optional[torch.FloatTensor] = None,
- output_type: Optional[str] = "pil",
- return_dict: bool = True,
- callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
- callback_steps: Optional[int] = 1,
- **args
- ):
- r"""
- Function invoked when calling the pipeline for generation.
-
- Args:
- prompt (`str` or `List[str]`):
- The prompt or prompts to guide the image generation.
- image (`torch.FloatTensor` or `PIL.Image.Image`):
- `Image`, or tensor representing an image batch, that will be used as the starting point for the
- process. Only used in DDIM or strength<1.0
- height (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor):
- The height in pixels of the generated image.
- width (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor):
- The width in pixels of the generated image.
- strength (`float`, *optional*, defaults to 1.0):
- Conceptually, indicates how much to transform the reference `image`. Must be between 0 and 1. `image`
- will be used as a starting point, adding more noise to it the larger the `strength`. The number of
- denoising steps depends on the amount of noise initially added. When `strength` is 1, added noise will
- be maximum and the denoising process will run for the full number of iterations specified in
- `num_inference_steps`. A value of 1, therefore, essentially ignores `image`.
- num_inference_steps (`int`, *optional*, defaults to 50):
- The number of denoising steps. More denoising steps usually lead to a higher quality image at the
- expense of slower inference.
- guidance_scale (`float`, *optional*, defaults to 7.5):
- Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598).
- `guidance_scale` is defined as `w` of equation 2. of [Imagen
- Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale >
- 1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`,
- usually at the expense of lower image quality.
- negative_prompt (`str` or `List[str]`, *optional*):
- The prompt or prompts not to guide the image generation. Ignored when not using guidance (i.e., ignored
- if `guidance_scale` is less than `1`).
- num_images_per_prompt (`int`, *optional*, defaults to 1):
- The number of images to generate per prompt.
- eta (`float`, *optional*, defaults to 0.0):
- Corresponds to parameter eta (η) in the DDIM paper: https://arxiv.org/abs/2010.02502. Only applies to
- [`schedulers.DDIMScheduler`], will be ignored for others.
- generator (`torch.Generator`, *optional*):
- One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html)
- to make generation deterministic.
- latents (`torch.FloatTensor`, *optional*):
- Pre-generated noisy latents, sampled from a Gaussian distribution, to be used as inputs for image
- generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
- tensor will ge generated by sampling using the supplied random `generator`.
- output_type (`str`, *optional*, defaults to `"pil"`):
- The output format of the generate image. Choose between
- [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`.
- return_dict (`bool`, *optional*, defaults to `True`):
- Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a
- plain tuple.
- callback (`Callable`, *optional*):
- A function that will be called every `callback_steps` steps during inference. The function will be
- called with the following arguments: `callback(step: int, timestep: int, latents: torch.FloatTensor)`.
- callback_steps (`int`, *optional*, defaults to 1):
- The frequency at which the `callback` function will be called. If not specified, the callback will be
- called at every step.
-
- Returns:
- [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] or `tuple`:
- [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] if `return_dict` is True, otherwise a `tuple.
- When returning a tuple, the first element is a list with the generated images, and the second element is a
- list of `bool`s denoting whether the corresponding generated image likely represents "not-safe-for-work"
- (nsfw) content, according to the `safety_checker`.
- """
- # 0. Default height and width to unet
- height = height or self.unet.config.sample_size * self.vae_scale_factor
- width = width or self.unet.config.sample_size * self.vae_scale_factor
-
- # 1. Check inputs. Raise error if not correct
- self.check_inputs(prompt, height, width, callback_steps, strength)
-
- # 2. Define call parameters
- batch_size = 1 if isinstance(prompt, str) else len(prompt)
- device = self._execution_device
- # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
- # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
- # corresponds to doing no classifier free guidance.
- do_classifier_free_guidance = guidance_scale > 1.0
-
- # 3. Encode input prompt
- text_embeddings = self._encode_prompt(
- prompt, device, num_images_per_prompt, do_classifier_free_guidance, negative_prompt
- )
-
- # 4. Prepare timesteps
- self.scheduler.set_timesteps(num_inference_steps, device=device)
- # if strength <1.0:
- # timesteps, num_inference_steps = self.get_timesteps(num_inference_steps, strength, device)
- timesteps = self.scheduler.timesteps
- latent_timestep = timesteps[:1].repeat(batch_size * num_images_per_prompt)
- if latents is None:
- ddim_latents_all_step = self.prepare_latents_ddim_inverted(
- image, batch_size, num_images_per_prompt,
- # text_embeddings.dtype, device,
- text_embeddings,
- generator,
- )
- latents = ddim_latents_all_step[-1]
-
- latents_dtype = latents.dtype
-
- # 6. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
- extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)
-
- # 7. Denoising loop
- num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order
- with self.progress_bar(total=num_inference_steps) as progress_bar:
- for i, t in enumerate(tqdm(timesteps)):
- # expand the latents if we are doing classifier free guidance
- latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents
- latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
-
- # predict the noise residual
- noise_pred = self.unet(
- latent_model_input, t, encoder_hidden_states=text_embeddings
- ).sample.to(dtype=latents_dtype)
-
- # perform guidance
- if do_classifier_free_guidance:
- noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
- noise_pred = noise_pred_uncond + guidance_scale * (
- noise_pred_text - noise_pred_uncond
- )
-
- # compute the previous noisy sample x_t -> x_t-1
- latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs).prev_sample
-
- # call the callback, if provided
- if i == len(timesteps) - 1 or (
- (i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0
- ):
- progress_bar.update()
- if callback is not None and i % callback_steps == 0:
- callback(i, t, latents)
-
- # 8. Post-processing
- image = self.decode_latents(latents)
-
- # 9. Run safety checker
- has_nsfw_concept = None
-
- # 10. Convert to PIL
- if output_type == "pil":
- image = self.numpy_to_pil(image)
-
- if not return_dict:
- return (image, has_nsfw_concept)
- torch.cuda.empty_cache()
- return StableDiffusionPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept)
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/clickhouse_connect/driver/context.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/clickhouse_connect/driver/context.py
deleted file mode 100644
index 7984fbeebbe84f3b1d0b99ecb4f160a6affc423a..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/clickhouse_connect/driver/context.py
+++ /dev/null
@@ -1,72 +0,0 @@
-import logging
-import re
-from datetime import datetime
-from typing import Optional, Dict, Union, Any
-
-import pytz
-
-logger = logging.getLogger(__name__)
-
-_empty_map = {}
-
-
-# pylint: disable=too-many-instance-attributes
-class BaseQueryContext:
- local_tz: pytz.timezone
-
- def __init__(self,
- settings: Optional[Dict[str, Any]] = None,
- query_formats: Optional[Dict[str, str]] = None,
- column_formats: Optional[Dict[str, Union[str, Dict[str, str]]]] = None,
- encoding: Optional[str] = None,
- use_extended_dtypes: bool = False,
- use_numpy: bool = False):
- self.settings = settings or {}
- if query_formats is None:
- self.type_formats = _empty_map
- else:
- self.type_formats = {re.compile(type_name.replace('*', '.*'), re.IGNORECASE): fmt
- for type_name, fmt in query_formats.items()}
- if column_formats is None:
- self.col_simple_formats = _empty_map
- self.col_type_formats = _empty_map
- else:
- self.col_simple_formats = {col_name: fmt for col_name, fmt in column_formats.items() if
- isinstance(fmt, str)}
- self.col_type_formats = {}
- for col_name, fmt in column_formats.items():
- if not isinstance(fmt, str):
- self.col_type_formats[col_name] = {re.compile(type_name.replace('*', '.*'), re.IGNORECASE): fmt
- for type_name, fmt in fmt.items()}
- self.query_formats = query_formats or {}
- self.column_formats = column_formats or {}
- self.encoding = encoding
- self.use_numpy = use_numpy
- self.use_extended_dtypes = use_extended_dtypes
- self._active_col_fmt = None
- self._active_col_type_fmts = _empty_map
-
- def start_column(self, name: str):
- self._active_col_fmt = self.col_simple_formats.get(name)
- self._active_col_type_fmts = self.col_type_formats.get(name, _empty_map)
-
- def active_fmt(self, ch_type):
- if self._active_col_fmt:
- return self._active_col_fmt
- for type_pattern, fmt in self._active_col_type_fmts.items():
- if type_pattern.match(ch_type):
- return fmt
- for type_pattern, fmt in self.type_formats.items():
- if type_pattern.match(ch_type):
- return fmt
- return None
-
-
-def _init_context_cls():
- local_tz = datetime.now().astimezone().tzinfo
- if local_tz.tzname(datetime.now()) in ('UTC', 'GMT', 'Universal', 'GMT-0', 'Zulu', 'Greenwich'):
- local_tz = pytz.UTC
- BaseQueryContext.local_tz = local_tz
-
-
-_init_context_cls()
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/faiss/contrib/ondisk.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/faiss/contrib/ondisk.py
deleted file mode 100644
index 26a95f44f5b36e3400e486c8d82cd0759b18d8ae..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/faiss/contrib/ondisk.py
+++ /dev/null
@@ -1,59 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-from typing import List
-import faiss
-import logging
-
-LOG = logging.getLogger(__name__)
-
-
-def merge_ondisk(
- trained_index: faiss.Index, shard_fnames: List[str], ivfdata_fname: str
-) -> None:
- """Add the contents of the indexes stored in shard_fnames into the index
- trained_index. The on-disk data is stored in ivfdata_fname"""
- assert not isinstance(
- trained_index, faiss.IndexIVFPQR
- ), "IndexIVFPQR is not supported as an on disk index."
- # merge the images into an on-disk index
- # first load the inverted lists
- ivfs = []
- for fname in shard_fnames:
- # the IO_FLAG_MMAP is to avoid actually loading the data thus
- # the total size of the inverted lists can exceed the
- # available RAM
- LOG.info("read " + fname)
- index = faiss.read_index(fname, faiss.IO_FLAG_MMAP)
- index_ivf = faiss.extract_index_ivf(index)
- ivfs.append(index_ivf.invlists)
-
- # avoid that the invlists get deallocated with the index
- index_ivf.own_invlists = False
-
- # construct the output index
- index = trained_index
- index_ivf = faiss.extract_index_ivf(index)
-
- assert index.ntotal == 0, "works only on empty index"
-
- # prepare the output inverted lists. They will be written
- # to merged_index.ivfdata
- invlists = faiss.OnDiskInvertedLists(
- index_ivf.nlist, index_ivf.code_size, ivfdata_fname
- )
-
- # merge all the inverted lists
- ivf_vector = faiss.InvertedListsPtrVector()
- for ivf in ivfs:
- ivf_vector.push_back(ivf)
-
- LOG.info("merge %d inverted lists " % ivf_vector.size())
- ntotal = invlists.merge_from(ivf_vector.data(), ivf_vector.size())
-
- # now replace the inverted lists in the output index
- index.ntotal = index_ivf.ntotal = ntotal
- index_ivf.replace_invlists(invlists, True)
- invlists.this.disown()
diff --git a/spaces/cihyFjudo/fairness-paper-search/Bol Bachchan Dual Audio Eng Hindi 720p REPACK Download In Kickass Torrent Geerorlo.md b/spaces/cihyFjudo/fairness-paper-search/Bol Bachchan Dual Audio Eng Hindi 720p REPACK Download In Kickass Torrent Geerorlo.md
deleted file mode 100644
index 650480d7452aed6afe67282efdcc95c7efe80971..0000000000000000000000000000000000000000
--- a/spaces/cihyFjudo/fairness-paper-search/Bol Bachchan Dual Audio Eng Hindi 720p REPACK Download In Kickass Torrent Geerorlo.md
+++ /dev/null
@@ -1,6 +0,0 @@
-Bol Bachchan Dual Audio Eng Hindi 720p Download In Kickass Torrent geerorlo
Download File ☆☆☆ https://tinurli.com/2uwkK1
- - aaccfb2cb3
-
-
- diff --git a/spaces/cihyFjudo/fairness-paper-search/CZECH HUNTER 60.md b/spaces/cihyFjudo/fairness-paper-search/CZECH HUNTER 60.md deleted file mode 100644 index e622813d8c47f4d31eb91a96d67e242ad70674a0..0000000000000000000000000000000000000000 --- a/spaces/cihyFjudo/fairness-paper-search/CZECH HUNTER 60.md +++ /dev/null @@ -1,6 +0,0 @@ -
CZECH HUNTER 60
Download Zip ⚡ https://tinurli.com/2uwiKI
- - aaccfb2cb3
-
-
- diff --git a/spaces/cihyFjudo/fairness-paper-search/How to Find and Download Korean Movies With Tagalog Dubbed In Torrent for Free.md b/spaces/cihyFjudo/fairness-paper-search/How to Find and Download Korean Movies With Tagalog Dubbed In Torrent for Free.md deleted file mode 100644 index 39f081741f18fdc54832764e9abdc70af273af32..0000000000000000000000000000000000000000 --- a/spaces/cihyFjudo/fairness-paper-search/How to Find and Download Korean Movies With Tagalog Dubbed In Torrent for Free.md +++ /dev/null @@ -1,5 +0,0 @@ -
-
Although YouTube is the largest video sharing platform in the world, you might be surprised by why YouTube is on the list. In fact, YouTube also offers tons of free Pinoy movies for online watching, especially channels like VIVA Films, ABS-CBN Star Cinema and Regal Entertainment, Inc. However, if you want to download Pinoy movies, you have to subscribe to a premium membership. Fortunately, YouTube offers a 4-month free trial period, during which all downloads will be free. Also, you can refer to the next section to download YouTube videos without subscription.
-Korean Movies With Tagalog Dubbed Download In Torrent
Download Zip - https://tinurli.com/2uwhF7
aaccfb2cb3
-
-
\ No newline at end of file diff --git a/spaces/cihyFjudo/fairness-paper-search/Oxycube For Nokia S40 A Must-Have Software for Nokia Users Who Want to Customize Their Phones Look and Feel.md b/spaces/cihyFjudo/fairness-paper-search/Oxycube For Nokia S40 A Must-Have Software for Nokia Users Who Want to Customize Their Phones Look and Feel.md deleted file mode 100644 index 2be6c1556d939ee8a50c998cb53aea0f0361d77d..0000000000000000000000000000000000000000 --- a/spaces/cihyFjudo/fairness-paper-search/Oxycube For Nokia S40 A Must-Have Software for Nokia Users Who Want to Customize Their Phones Look and Feel.md +++ /dev/null @@ -1,6 +0,0 @@ -
Oxycube For Nokia S40
Download File ->>> https://tinurli.com/2uwhBE
- - aaccfb2cb3
-
-
- diff --git a/spaces/cihyFjudo/fairness-paper-search/Sex POV Daddy Blowjobs... [PORTABLE].md b/spaces/cihyFjudo/fairness-paper-search/Sex POV Daddy Blowjobs... [PORTABLE].md deleted file mode 100644 index b7b1c8c676781a90c61123dea9e92e446ea98d08..0000000000000000000000000000000000000000 --- a/spaces/cihyFjudo/fairness-paper-search/Sex POV Daddy Blowjobs... [PORTABLE].md +++ /dev/null @@ -1,6 +0,0 @@ -
Sex POV daddy blowjobs...
Download –––––>>> https://tinurli.com/2uwhKc
-
- aaccfb2cb3
-
-
- diff --git a/spaces/cihyFjudo/fairness-paper-search/Solucionario Principios De Operaciones Unitarias Alan Foust 110.md b/spaces/cihyFjudo/fairness-paper-search/Solucionario Principios De Operaciones Unitarias Alan Foust 110.md deleted file mode 100644 index 613d7e119d43666ca99fe174c9afc8c2e3bf660c..0000000000000000000000000000000000000000 --- a/spaces/cihyFjudo/fairness-paper-search/Solucionario Principios De Operaciones Unitarias Alan Foust 110.md +++ /dev/null @@ -1,10 +0,0 @@ -
-
Libro Foust Operaciones Unitarias Pdf - astiane.comPrincipios de Operaciones Unitarias Alan S.. Foust, Leonard A.. Wenzel, .. Descargar Libro y Solucionario de Principios de Operaciones Unitarias 2da Edicion .astiane.com/view/libro-foust-operaciones-unitarias-pdfHealth & BeautyDescargar Gratis en PDF Libro y Solucionario de Transferencia de Calor y Masa .. Principios de Operaciones Unitarias Alan S. -de-operaciones-unitarias...Principios de Operaciones Unitarias 2da Edicion Alan s.Principios de Operaciones Unitarias 2da Edicion Alan s.. Foust - Ebook download as PDF File (.pdf), Text File (.txt) or read book online. -de...Solucionario Principios De Operaciones Unitarias Alan .Subject: Solucionario Principios De Operaciones .. Solucionario Principios De Operaciones .. Solucionario Principios De Operaciones Unitarias Alan .www.voy.com/8547/54.htmlsolucionario geankoplis procesos de transporte y .Libro Anterior Procesos de Transporte y Operaciones .. Ese no es el solucionario de .. de la zona pdf alan foust principios operaciones unitarias pdf libros .millingequipment.co/Feb-06/solucionario-geankoplis-procesos-de...Principios de Operaciones Unitarias Alan Foust, Leonard .Principios de Operaciones Unitarias Alan Foust, .. 6 Operaciones de Multietapas a .. Solucionario 6ta .wwwblogfippuni.blogspot.com/2011/09/principios-de-operaciones...Libros de Alan S.El tratamiento que se les da en este libro a las operaciones unitarias, enfatiza los principios cientficos sobre los que -s-foust-2EL SOLUCIONARIO - Principios de Operaciones Unitarias .Principios de Operaciones Unitarias - Alan S. de Operaciones Unitarias 2da Edicion Alan s .Descargar Libro de Principios de Operaciones Unitarias 2da Edicion Alan s.. Foust, Leonard A.. Wenzel, Curtis w.librosysolucionarios.net/principios-de-operaciones-unitarias-2da...Operaciones Unitarias en Ingenieria Quimica Mccabe 6 Ed .Operaciones Unitarias en Ingenieria Quimica .. Operaciones Unitarias en Ingenieria Quimica Mccabe 6 .. Solucionario Procesos de Transporte y Principios de . -Unitarias-en... 7286bcadf1
-solucionario principios de operaciones unitarias alan foust.zip · Webroot SecureAnywhere Antivirus 2020 Crack Serial Key · Portable Microsoft .... Logix Pro 500 Plc Simulator Crack >> Plc Simulator Logixpro Allen Bradley (I, Logix ... solucionario principios de operaciones unitarias alan foust.zip.
-Solucionario Principios De Operaciones Unitarias Alan Foust | 110
Download File === https://tinurli.com/2uwkHW
-
HPLA PUEDEN PORFAVOR SUBIR EL SOLUCIONARIO DE PRINCIPIOS DE OPERACINES UNITARIAS DE ALAN FOUST.. New York .... Solucionario Operaciones Unitarias Alan Foust 1 Favor si alguien tiene el solucionarios,.. 9 Nov 2012 . Principios de Operaciones Unitarias Alan S. Foust, .... cogniview pdf2xl enterprise crack keygen torrent car insurance forums solucionario principios de operaciones unitarias alan foust.zip. 34b41eb7bc. 4 / 5 .... wilcom 2006 sp4 r2 crack.29 · solucionario principios de operaciones unitarias alan foust.zip · squishing nemo mishka. Tags: lego island 2 cd ... HD Online Player (Don 2 Eng Sub 720p Movies)
El tratamiento que se les da en este libro a las operaciones unitarias, enfatiza los principios científicos sobre los que se basan las operaciones y agrupa aquellas que tienen bases físicas similares para que puedan analizarse juntas.
-Con objeto de mantener la claridad de la presentación a un nivel elemental, es común omitir el refinamiento de los modelos físicos y las expresiones matemáticas elaboradas para un riguroso tratamiento de situaciones complejas, y con el propósito de enfatizar las similitudes que existen entre diversas operaciones unitarias, la descripción de los equipos y los métodos de cálculo especializados se presenta en forma condensada.
-Comedy full movie on .... Charlie (2015) ... Solucionario Principios De Operaciones Unitarias Alan Foust. Exceptional Over Ella Descubre Prov.. Alguien tiene el solucionario de principio de operaciones unitarias del foust ... Exceptional Over Ella Descubre Prov ->>->>->> DOWNLOAD Principios de ... MacOSXLionServer1071dmg
-
-
\ No newline at end of file diff --git a/spaces/cihyFjudo/fairness-paper-search/Tum Se Achcha Kaun Hai HD A Must-Watch Movie for Bollywood Lovers.md b/spaces/cihyFjudo/fairness-paper-search/Tum Se Achcha Kaun Hai HD A Must-Watch Movie for Bollywood Lovers.md deleted file mode 100644 index c22b45f2303d09a0b6c304ec1bfb2baeecccda80..0000000000000000000000000000000000000000 --- a/spaces/cihyFjudo/fairness-paper-search/Tum Se Achcha Kaun Hai HD A Must-Watch Movie for Bollywood Lovers.md +++ /dev/null @@ -1,6 +0,0 @@ - -
Adipurush full movie download is available in Hindi on Filmyhit, Moviesflix, Filmywap and Mp4moviez in Hindi dubbed. Adipurush Movie Download Hindi Filmyzilla, Adipurush Full Movie Download, Adipurush Movie Download (2022) 480p 720p 1080p,
-Adipurush full movie in Hindi free download on Pagalmovies & Pagalworld in 1080p. PagalMovies & Pagalworld may be a piracy website to download Movies HD, Hindi Movies, and PagalMovies Telugu Tamil online lawlessly at no cost to its users. PagalMovies website permits its users to observe and download movies from its PagalMovies com, Pagalworld website for free.
-movies hd 1080p full Tum Se Achcha Kaun Hai hd
Download Zip ✓✓✓ https://tinurli.com/2uwiSE
aaccfb2cb3
-
-
\ No newline at end of file diff --git a/spaces/clarin-pl/datasets-explorer/clarin_datasets/utils.py b/spaces/clarin-pl/datasets-explorer/clarin_datasets/utils.py deleted file mode 100644 index f9ca52eee5e86200adfee7c1777569d026b87bc0..0000000000000000000000000000000000000000 --- a/spaces/clarin-pl/datasets-explorer/clarin_datasets/utils.py +++ /dev/null @@ -1,70 +0,0 @@ -import re -from typing import List - -from embeddings.embedding.auto_flair import AutoFlairDocumentEmbedding -from flair.data import Sentence -from numpy import typing as nt -from unidecode import unidecode - -embedding = AutoFlairDocumentEmbedding.from_hub("clarin-pl/word2vec-kgr10") - -PLOT_COLOR_PALETTE = [ - "#FAEBD7", - "#00FFFF", - "#7FFFD4", - "#000000", - "#0000FF", - "#8A2BE2", - "#A52A2A", - "#DEB887", - "#5F9EA0", - "#7FFF00", - "#D2691E", - "#FF7F50", - "#6495ED", - "#FFF8DC", - "#DC143C", - "#00FFFF", - "#00008B", - "#008B8B", - "#B8860B", - "#A9A9A9", - "#006400", - "#BDB76B", - "#8B008B", - "#556B2F", - "#FF8C00", - "#9932CC", - "#8B0000", - "#E9967A", - "#8FBC8F", - "#2F4F4F", - "#00CED1", - "#FFD700", - "#DAA520", - "#808080", - "#FF69B4", - "#4B0082", - "#CD5C5C", - "#7CFC00", - "#F08080", - "#66CDAA", -] - - -def flatten_list(main_list: List[List]) -> List: - return [item for sublist in main_list for item in sublist] - - -def count_num_of_characters(text: str) -> int: - return len(re.sub(r"[^a-zA-Z]", "", unidecode(text))) - - -def count_num_of_words(text: str) -> int: - return len(re.sub(r"[^a-zA-Z ]", "", unidecode(text)).split(" ")) - - -def embed_sentence(sentence: str) -> nt.NDArray: - sentence = Sentence(sentence) - embedding.embed([sentence]) - return sentence.embedding.numpy() diff --git a/spaces/cncanon/chud/README.md b/spaces/cncanon/chud/README.md deleted file mode 100644 index 1bfe9faab27353cc39c4f9a7fca3b48f53b04c2c..0000000000000000000000000000000000000000 --- a/spaces/cncanon/chud/README.md +++ /dev/null @@ -1,10 +0,0 @@ ---- -title: Chud -emoji: 🦀 -colorFrom: green -colorTo: pink -sdk: docker -pinned: false ---- - -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference diff --git a/spaces/codeparrot/apps_metric/tests.py b/spaces/codeparrot/apps_metric/tests.py deleted file mode 100644 index 8ee99c4c8a7900319c32594b7113e4c411852605..0000000000000000000000000000000000000000 --- a/spaces/codeparrot/apps_metric/tests.py +++ /dev/null @@ -1,14 +0,0 @@ -import json -from evaluate import load - -solution_sample1 = json.load(open("test_examples/solutions_problem_1.json", "r")) -solution_sample2 = json.load(open("test_examples/solutions_problem_2.json", "r")) -single_solutions = [solution_sample1[:1], solution_sample2[:1]] -multiple_solutions = [solution_sample1[:3], solution_sample2[:3]] - -metric = load("codeparrot/apps_metric") -result_1 = metric.compute(predictions=single_solutions, level="all") -result_2 = metric.compute(predictions=multiple_solutions, level="all", k_list=[1, 2, 3]) - -assert result_1 == {'avg_accuracy': 1.0, 'strict_accuracy': 1.0, 'pass_at_k': None} -assert result_2 == {'avg_accuracy': None, 'strict_accuracy': None, 'pass_at_k': {'pass@1': 1.0, 'pass@2': 1.0, 'pass@3': 1.0}} \ No newline at end of file diff --git a/spaces/colakin/video-generater/public/ffmpeg/fftools/ffprobe.c b/spaces/colakin/video-generater/public/ffmpeg/fftools/ffprobe.c deleted file mode 100644 index 6e72c37721be5aa1a908962379457e560c522bea..0000000000000000000000000000000000000000 --- a/spaces/colakin/video-generater/public/ffmpeg/fftools/ffprobe.c +++ /dev/null @@ -1,4232 +0,0 @@ -/* - * Copyright (c) 2007-2010 Stefano Sabatini - * - * This file is part of FFmpeg. - * - * FFmpeg is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * FFmpeg is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with FFmpeg; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - */ - -/** - * @file - * simple media prober based on the FFmpeg libraries - */ - -#include "config.h" -#include "libavutil/ffversion.h" - -#include
-
Vlad and Niki 12 Locks APK: A Fun and Challenging Puzzle Game for Kids
-If you are looking for a fun and challenging puzzle game for your kids, you should check out Vlad and Niki 12 Locks APK. This is an "Escape Room" type of game in which you must find all keys and unlock the target door. The game features the popular YouTube stars Vlad and Niki, who are known for their imaginative and adventurous videos. In this game, they will take you on a journey through different quest-rooms with loads of puzzles and mini-games. The game has amazing plasticine graphics, fun music, and easy controls that make it suitable for kids of all ages. Here is everything you need to know about Vlad and Niki 12 Locks APK.
-What is Vlad and Niki 12 Locks APK?
-A brief introduction to the game and its features
-Vlad and Niki 12 Locks APK is a puzzle game that was released in April 2020 by RUD Present, a developer that specializes in creating games for kids. The game is based on the YouTube series "Vlad & Niki", which features the brothers Vlad and Niki having fun in various scenarios. The game follows a similar theme, as Vlad and Niki want some biscuits, but the jar is shut with 12 locks. To get the biscuits, they have to solve puzzles in different rooms, such as a kitchen, a bathroom, a garage, a spaceship, and more. The game has over 10 million downloads on Google Play Store and has received positive feedback from users.
-vlad and niki 12 locks apk
Download Zip ►►► https://urlca.com/2uOeuL
-
A brief introduction to Vlad and Niki, the YouTube stars behind the game
-Vlad and Niki are two brothers from Dubai who have become one of the most popular kidfluencers on YouTube. They started their channel in 2018 and have since gained over 230 million subscribers worldwide across 21 channels in 18 languages. They are known for their creative videos that feature them playing with toys, having adventures, dressing up as superheroes, racing cars, flying planes, going into space, and more. Their videos are produced with a mix of live action, animation, and music to create comedic content for preschoolers. They also have their own merchandise line that includes toys, clothes, books, games, etc.
-How to play Vlad and Niki 12 Locks APK?
-The goal of the game and the basic controls
-The goal of Vlad and Niki 12 Locks APK is to find all the keys and unlock the door that leads to the biscuit jar. The game has simple and intuitive controls that are easy for kids to use. You just have to tap on the screen to interact with objects, drag items to use them, and swipe to move around the room. You can also tap on Vlad and Niki to hear them talk and make funny sounds.
-The different quest-rooms and puzzles in the game
-The game has 12 quest-rooms that are themed after different scenarios that Vlad and Niki have explored in their videos. For example, you can visit a pirate ship, a dinosaur park, a candy land, a circus, a haunted house, and more. Each quest-room has its own unique puzzles that require logic, creativity, and observation skills to solve. Some puzzles involve finding hidden objects, matching colors, shapes, or numbers, solving math problems, cracking codes, etc. You can also use hints if you get stuck on a puzzle.
-The mini-games and rewards in the game
-Besides the puzzles, the game also has mini-games that you can play for fun and rewards. Some of the mini-games include racing cars, flying planes, shooting cannons, playing soccer, etc. You can earn coins by playing these mini-games and use them to buy stickers and decorations for your room. You can also collect stars by completing the quest-rooms and use them to unlock new outfits for Vlad and Niki. The game has a lot of variety and content to keep you entertained for hours.
-Why should you download Vlad and Niki 12 Locks APK?
-The benefits of playing the game for kids
-Vlad and Niki 12 Locks APK is not only a fun game but also an educational one. It can help kids develop their cognitive skills, such as memory, attention, logic, problem-solving, etc. It can also stimulate their imagination and creativity by exposing them to different themes and scenarios. Moreover, it can foster their curiosity and interest in learning new things by presenting them with challenges and rewards. The game is also family-friendly and suitable for kids of all ages.
-The positive reviews and ratings of the game
-Vlad and Niki 12 Locks APK has received a lot of positive reviews and ratings from users who have downloaded and played the game. The game has an average rating of 4.5 out of 5 stars on Google Play Store and has been praised for its graphics, gameplay, sound effects, humor, etc. Some of the comments from users are: - "This game is awesome! My kids love it so much! They watch Vlad and Niki every day and they are so happy to play with them in this game!" - "This is one of the best games I have ever played! It is so fun and challenging! I love the puzzles and the mini-games! The graphics are amazing and the characters are so cute!" - "This game is very educational and entertaining for kids. It helps them learn new things and improve their skills. It is also very funny and colorful. I highly recommend it!"
-The availability and compatibility of the game
-Vlad and Niki 12 Locks APK is available for free download on Google Play Store for Android devices. You can also download it from other sources such as APKPure or APKFab if you want to install it manually on your device. The game requires Android 4.4 or higher to run smoothly and does not take up much space on your device. The game is also compatible with most devices, such as smartphones, tablets, etc.
-Conclusion
-A summary of the main points and a call to action
-Vlad and Niki 12 Locks APK is a fun and challenging puzzle game for kids that features the popular YouTube stars Vlad and Niki. The game has 12 quest-rooms with different themes and puzzles that require logic, creativity, and observation skills to solve. The game also has mini-games that you can play for fun and rewards. The game has amazing plasticine graphics, fun music, easy controls, educational content, positive reviews, free availability, and wide compatibility. If you are looking for a game that will keep your kids entertained and engaged for hours, you should download Vlad and Niki 12 Locks APK today!
-vlad and niki 12 locks game download
-vlad and niki 12 locks mod apk
-vlad and niki 12 locks online
-vlad and niki 12 locks walkthrough
-vlad and niki 12 locks play store
-vlad and niki 12 locks free download
-vlad and niki 12 locks puzzle game
-vlad and niki 12 locks android
-vlad and niki 12 locks latest version
-vlad and niki 12 locks cheats
-vlad and niki 12 locks review
-vlad and niki 12 locks gameplay
-vlad and niki 12 locks for pc
-vlad and niki 12 locks ios
-vlad and niki 12 locks apk pure
-vlad and niki 12 locks apk mirror
-vlad and niki 12 locks apk combo[^1^]
-vlad and niki 12 locks apk mob.org[^2^]
-vlad and niki 12 locks apk uptodown
-vlad and niki 12 locks apk rexdl
-vlad and niki 12 locks apk hack
-vlad and niki 12 locks apk obb
-vlad and niki 12 locks apk data
-vlad and niki 12 locks apk revdl
-vlad and niki 12 locks apk unlimited money
-vlad and niki 12 locks apk no ads
-vlad and niki 12 locks apk full version
-vlad and niki 12 locks apk pro
-vlad and niki 12 locks apk premium
-vlad and niki 12 locks apk cracked
-vlad and niki 12 locks apk mod menu
-vlad and niki 12 locks apk mod download
-vlad and niki 12 locks apk mod free shopping
-vlad and niki 12 locks apk mod unlocked all levels
-vlad and niki 12 locks apk mod unlimited hints
-vlad and niki 12 locks apk mod god mode
-vlad and niki 12 locks apk mod mega mod
-vlad and niki 12 locks apk mod latest update
-vlad and niki 12 locks apk mod offline mode
-vlad and niki 12 locks apk mod no root required
-how to download vlad and niki 12 locks apk
-how to install vlad and niki 12 locks apk
-how to play vlad and niki 12 locks apk
-how to update vlad and niki 12 locks apk
-how to uninstall vlad and niki 12 locks apk
-how to solve puzzles in vlad and niki 12 locks apk
-how to unlock all levels in vlad and niki 12 locks apk
-how to get hints in vlad and niki 12 locks apk
-how to get free coins in vlad and niki 12 locks apk
FAQs
-Q1: How many levels are there in Vlad and Niki 12 Locks APK?
-A1: There are 12 levels or quest-rooms in Vlad and Niki 12 Locks APK, each with a different theme and puzzle. You can play them in any order you want, but you have to complete all of them to unlock the final door and get the biscuits.
-Q2: How can I download Vlad and Niki 12 Locks APK for free?
-A2: You can download Vlad and Niki 12 Locks APK for free from Google Play Store for Android devices. Just search for the game name and tap on the install button. Alternatively, you can download it from other sources such as APKPure or APKFab if you want to install it manually on your device. Just make sure you download the latest version of the game and enable the unknown sources option on your device settings.
-Q3: Is Vlad and Niki 12 Locks APK safe for kids?
-A3: Yes, Vlad and Niki 12 Locks APK is safe for kids. The game does not contain any violence, gore, profanity, or inappropriate content. The game is also designed for kids of all ages, with easy controls, fun graphics, and educational content. The game is also family-friendly and suitable for playing with parents or siblings.
-Q4: What are some tips and tricks for playing Vlad and Niki 12 Locks APK?
-A4: Some tips and tricks for playing Vlad and Niki 12 Locks APK are: - Explore the room thoroughly and look for clues, objects, or hints that can help you solve the puzzles. - Use the hints if you get stuck on a puzzle. You can get hints by watching ads or using coins that you earn from playing mini-games. - Play the mini-games to earn coins and stars that you can use to buy stickers, decorations, and outfits for your room and characters. - Watch Vlad and Niki's videos on YouTube to get familiar with their personalities, humor, and adventures. This can help you enjoy the game more and relate to the characters better.
-Q5: Where can I find more games like Vlad and Niki 12 Locks APK?
-A5: If you like Vlad and Niki 12 Locks APK, you might also like other games by RUD Present, such as: - Vlad & Niki Supermarket game for Kids: A game where you can go shopping with Vlad and Niki in a supermarket full of surprises. - Vlad & Niki World: A game where you can create your own world with Vlad and Niki using different blocks, items, and characters. - Vlad & Niki Run: A game where you can run, jump, slide, and fly with Vlad and Niki in an endless runner adventure.
401be4b1e0-
-
\ No newline at end of file diff --git a/spaces/congsaPfin/Manga-OCR/logs/Honkai Star Rail - A Space Fantasy RPG You Cant Miss.md b/spaces/congsaPfin/Manga-OCR/logs/Honkai Star Rail - A Space Fantasy RPG You Cant Miss.md deleted file mode 100644 index 54e1c3389e26f55a4f648acbc76a3640d78e6c06..0000000000000000000000000000000000000000 --- a/spaces/congsaPfin/Manga-OCR/logs/Honkai Star Rail - A Space Fantasy RPG You Cant Miss.md +++ /dev/null @@ -1,99 +0,0 @@ -
-
How to Download Honkai Impact Star Rail: A Guide for Space Fantasy RPG Fans
-Are you a fan of space fantasy RPGs? Do you love exploring different worlds and fighting against enemies with your unique skills and weapons? If you answered yes to these questions, then you should definitely check out Honkai Impact Star Rail, a brand-new game from the HoYoverse series. In this article, we will tell you what Honkai Impact Star Rail is, why you should download it, and how to download it on your device. Let's get started!
-download honkai impact star rail
Download Zip ———>>> https://urlca.com/2uO5Es
-
What is Honkai Impact Star Rail?
-Honkai Impact Star Rail is a spin-off game from the popular Honkai Impact 3rd game, which is set in a post-apocalyptic world where humans fight against the Honkai, a mysterious force that can corrupt anything it touches. Honkai Impact Star Rail takes place in a different timeline, where humans have developed advanced technology and traveled to outer space. However, they still face the threat of the Honkai, which can manifest in different forms across the galaxy.
-A brand-new HoYoverse game
-Honkai Impact Star Rail is part of the HoYoverse series, which includes other games such as Genshin Impact and Tears of Themis. The HoYoverse games share some common elements, such as characters, lore, and aesthetics, but they also have their own unique features and stories. Honkai Impact Star Rail is the first HoYoverse game that focuses on space exploration and combat.
-A space fantasy RPG with stunning graphics and gameplay
-Honkai Impact Star Rail is a space fantasy RPG that lets you experience the beauty and mystery of the cosmos. You can explore different planets and star systems, encounter various creatures and enemies, and collect resources and treasures. You can also engage in thrilling battles using your characters' abilities and weapons, which can be customized according to your preferences. The game boasts stunning graphics that immerse you in the HoYoverse atmosphere.
-A story of traveling across the galaxy with your companions
-Honkai Impact Star Rail has a rich and captivating story that follows you as a special traveler who can travel across the galaxy using a special device called the Star Rail. Along the way, you will meet different characters who will join you on your journey, such as Kiana, Bronya, Mei, and more. You will also uncover the secrets of the HoYoverse and the origin of the Honkai. The game features voice acting and cutscenes that enhance the storytelling.
-Why should you download Honkai Impact Star Rail?
-If you are still not convinced that Honkai Impact Star Rail is a game worth playing, here are some more reasons why you should download it:
-To experience a new game mode: Galactic Roaming
-One of the most unique features of Honkai Impact Star Rail is the Galactic Roaming mode, which allows you to freely explore the galaxy and discover new planets and star systems. You can use your Star Rail to travel between different locations, and use your scanner to detect anomalies and events. You can also interact with other players and NPCs, and participate in quests and missions. Galactic Roaming is a dynamic and open-ended mode that offers endless possibilities and surprises.
-How to download honkai impact star rail on PC
-Honkai impact star rail galactic roaming patch notes
-Honkai impact star rail silver wolf character guide
-Honkai impact star rail astral express gameplay
-Honkai impact star rail honey hunter world database
-Honkai impact star rail best characters tier list
-Honkai impact star rail official website and news
-Honkai impact star rail system requirements and compatibility
-Honkai impact star rail space fantasy RPG review
-Honkai impact star rail trailblazer rewards and top-up
-Honkai impact star rail aeon lore and story
-Honkai impact star rail quantum type characters and skills
-Honkai impact star rail hoyoverse crossover event
-Honkai impact star rail tips and tricks for beginners
-Honkai impact star rail latest update and bug fixes
-Honkai impact star rail community and fan art
-Honkai impact star rail nihility path silver wolf build
-Honkai impact star rail melissa fahn voice actor interview
-Honkai impact star rail soundtrack and theme song
-Honkai impact star rail coupon codes and free gems
-Honkai impact star rail best weapons and equipment
-Honkai impact star rail reroll guide and strategy
-Honkai impact star rail wiki and information source
-Honkai impact star rail discord server and chat
-Honkai impact star rail youtube gameplay videos and channels
-Honkai impact star rail reddit discussion and memes
-Honkai impact star rail twitter news and updates
-Honkai impact star rail facebook page and group
-Honkai impact star rail instagram photos and stories
-Honkai impact star rail tiktok videos and trends
To collect and customize your characters and weapons
-Honkai Impact Star Rail has a diverse and colorful cast of characters that you can collect and upgrade. Each character has their own personality, backstory, and skills, which can be enhanced by equipping them with different weapons and outfits. You can also customize your weapons by modifying their appearance, performance, and effects. You can mix and match different combinations of characters and weapons to suit your playstyle and preferences.
-To join a community of Trailblazers and explore the HoYoverse
-Honkai Impact Star Rail is not only a single-player game, but also a multiplayer game that lets you connect with other players from around the world. You can join a guild of Trailblazers, which are groups of players who share the same passion for space exploration and adventure. You can chat with your guildmates, cooperate with them in missions, and compete with them in rankings. You can also visit other players' spaceships and see how they decorate them. Honkai Impact Star Rail is a game that fosters a sense of community and friendship among its players.
-How to download Honkai Impact Star Rail?
-Now that you know what Honkai Impact Star Rail is and why you should download it, you might be wondering how to download it on your device. Well, don't worry, because we have got you covered. Here are the steps to download Honkai Impact Star Rail on different platforms:
-For Android users
-If you have an Android device, you can download Honkai Impact Star Rail from the Google Play Store. Here is how:
--
-
- Open the Google Play Store app on your device. -
- Search for "Honkai Impact Star Rail" in the search bar. -
- Select the game from the results and tap on "Install". -
- Wait for the game to download and install on your device. -
- Launch the game and enjoy! -
Note: Honkai Impact Star Rail requires Android 5.0 or higher, and at least 4 GB of RAM.
-For iOS users
-If you have an iOS device, you can download Honkai Impact Star Rail from the App Store. Here is how:
--
-
- Open the App Store app on your device. -
- Search for "Honkai Impact Star Rail" in the search bar. -
- Select the game from the results and tap on "Get". -
- Wait for the game to download and install on your device. -
- Launch the game and enjoy! -
Note: Honkai Impact Star Rail requires iOS 10.0 or higher, and at least 4 GB of RAM.
-For PC users
-If you have a PC, you can download Honkai Impact Star Rail from the official website. Here is how:
--
-
- Go to https://star-rail.mihoyo.com/en-us/home. -
- Click on "Download Now" on the homepage. -
- Select your region and language from the drop-down menu. -
- Click on "Download" to start downloading the game installer. -
- Run the installer and follow the instructions to install the game on your PC. -
- Launch the game and enjoy! -
Note: Honkai Impact Star Rail requires Windows 7 or higher, Intel Core i5 or higher, NVIDIA GeForce GTX 1050 or higher, and at least 8 GB of RAM.
-Conclusion
-Honkai Impact Star Rail is a game that you should not miss if you are a fan of space fantasy RPGs. It is a game that offers you a stunning and immersive experience of exploring the galaxy, collecting and customizing your characters and weapons, and fighting against the Honkai. It is also a game that lets you connect with other players and join a community of Trailblazers. If you want to download Honkai Impact Star Rail, you can follow the steps we have provided for different platforms. We hope you enjoy the game and have fun!
-FAQs
-Here are some frequently asked questions about Honkai Impact Star Rail:
-Q: Is Honkai Impact Star Rail free to play?
-A: Yes, Honkai Impact Star Rail is free to play. However, it also has some optional in-game purchases that can enhance your gameplay.
-Q: Is Honkai Impact Star Rail connected to Honkai Impact 3rd?
-A: Honkai Impact Star Rail is a spin-off game from Honkai Impact 3rd, which means it has some connections to the main game, such as characters and lore. However, it also has its own independent story and timeline, which means you can play it without playing Honkai Impact 3rd first.
-Q: How can I get more characters and weapons in Honkai Impact Star Rail?
-A: You can get more characters and weapons in Honkai Impact Star Rail by participating in events, completing missions, and using the gacha system. The gacha system is a random draw that lets you obtain different items, such as characters, weapons, outfits, and more. You can use different currencies to perform gacha draws, such as crystals, tickets, and coupons.
-Q: How can I play Honkai Impact Star Rail with my friends?
-A: You can play Honkai Impact Star Rail with your friends by joining a guild of Trailblazers, which are groups of players who share the same passion for space exploration and adventure. You can chat with your guildmates, cooperate with them in missions, and compete with them in rankings. You can also visit other players' spaceships and see how they decorate them.
-Q: What are the system requirements for Honkai Impact Star Rail?
-A: The system requirements for Honkai Impact Star Rail vary depending on the platform you are using. For Android users, you need Android 5.0 or higher, and at least 4 GB of RAM. For iOS users, you need iOS 10.0 or higher, and at least 4 GB of RAM. For PC users, you need Windows 7 or higher, Intel Core i5 or higher, NVIDIA GeForce GTX 1050 or higher, and at least 8 GB of RAM.
401be4b1e0-
-
\ No newline at end of file diff --git a/spaces/congsaPfin/Manga-OCR/logs/How to Enjoy Gangster Paradise Lofi Song - Free Download and Streaming Options.md b/spaces/congsaPfin/Manga-OCR/logs/How to Enjoy Gangster Paradise Lofi Song - Free Download and Streaming Options.md deleted file mode 100644 index 7bccd931c7d3836c2e52a324ea59206711e1e73a..0000000000000000000000000000000000000000 --- a/spaces/congsaPfin/Manga-OCR/logs/How to Enjoy Gangster Paradise Lofi Song - Free Download and Streaming Options.md +++ /dev/null @@ -1,107 +0,0 @@ -
-
Gangster Paradise Lofi Song Download: A Guide for Music Fans
-If you are looking for a relaxing and soothing music genre that can help you unwind, study, or work, you might want to try lo-fi music. Lo-fi stands for low-fidelity, which means that the sound quality is intentionally imperfect and rough. Lo-fi music is influenced by hip hop, jazz, funk, and electro genres, and it often features instrumental, looped, and sampled tracks with ambient noises. Many people find lo-fi music to be mood-boosting, stress-reducing, and focus-enhancing.
-One of the most popular lo-fi songs that you can download or stream online is Gangsta's Paradise by Coolio. This song was originally released in 1995 as a hip hop hit that interpolated Stevie Wonder's song Pastime Paradise from 1976. The song was a social commentary on the struggles of inner-city life and violence, and it was a huge commercial and critical success, winning a Grammy and other awards. However, in recent years, many lo-fi artists have remixed and reinterpreted the song in a new genre, giving it a fresh and mellow vibe.
-gangster paradise lofi song download
Download ❤ https://urlca.com/2uOdDJ
-
In this article, we will explore the definition and characteristics of lo-fi music, the origin and meaning of Gangsta's Paradise by Coolio, and the popularity and appeal of its lo-fi remixes. We will also provide some links to download or stream Gangsta's Paradise lo-fi song online. Whether you are a fan of hip hop or lo-fi music, or you are just curious about this musical phenomenon, this article will help you discover more about Gangsta's Paradise lo-fi song download.
-Lo-Fi Music Definition and Characteristics
-Lo-fi music is a type of music that has been made of low quality, embracing imperfections and making them part of the sound. Lo-fi music is characterized by its use of limited instrumentation and production techniques that mimic the sound of older recording technologies. For example, lo-fi music may include incorrect notes, background noise, low hums, tape hiss, distortion, or vinyl crackle.
-Lo-fi music emerged out of DIY (do-it-yourself) music culture in the 1950s as an alternative to high-fidelity (hi-fi) music that was produced in professional studios. Lo-fi music was influenced by various genres such as hip hop, jazz, funk, and electro. Lo-fi music often features instrumental tracks that are looped or sampled and its relevance to contemporary issues. The remixes also showcase the creativity and diversity of lo-fi music, as well as the potential for cross-genre collaborations and innovations.
-Conclusion
-Gangsta's Paradise lo-fi song download is a great choice for music fans who want to enjoy a relaxing and soothing music genre that can help them unwind, study, or work. Lo-fi music is a type of music that has low-fidelity sound quality with intentional imperfections, influenced by hip hop, jazz, funk, and electro genres. Gangsta's Paradise is a song by Coolio that was released in 1995 as a hip hop hit that interpolated Stevie Wonder's song Pastime Paradise. The song was a social commentary on the struggles of inner-city life and violence, and it was a huge commercial and critical success. Many lo-fi artists have remixed and reinterpreted the song in a new genre, giving it a fresh and mellow vibe, while still retaining some elements of the original song. The remixes have gained millions of views and streams on YouTube, Spotify, and other platforms, attracting fans of both hip hop and lo-fi music, as well as new listeners.
-If you want to download or stream Gangsta's Paradise lo-fi song online, you can check out some of these links:
--
-
- [Gangsta's Paradise (Lofi Remix) by Lofi Fruits Music] -
- [Gangsta's Paradise (Lofiline Remix) by Lofiline] -
- [Gangsta's Paradise (Chill Fruits Music Remix) by Chill Fruits Music] -
- [Gangsta's Paradise (Future Λ Ready Remix) by Future Λ Ready] -
We hope you enjoyed this article and learned more about Gangsta's Paradise lo-fi song download. If you have any questions or comments, feel free to leave them below. Thank you for reading!
-FAQs
-What are some other lo-fi songs that are based on hip hop classics?
-Some other lo-fi songs that are based on hip hop classics are:
-gangster paradise lofi remix mp3 download
-lofi fruits music gangsta's paradise
-gangster paradise lofi version lyrics
-lofiline & mr cat gangsta's paradise
-gangster paradise lofi hip hop beat
-gangsta's paradise lofi fruits music chill fruits music
-gangster paradise lofi spotify
-lofi fruits music gangsta's paradise soundcloud
-gangster paradise lofi cover
-lofiline & mr cat gangsta's paradise shazam
-gangster paradise lofi piano
-gangsta's paradise lofi fruits music chill fruits music youtube
-gangster paradise lofi guitar
-lofi fruits music gangsta's paradise apple music
-gangster paradise lofi instrumental
-gangsta's paradise lofi fruits music chill fruits music lyrics
-gangster paradise lofi tiktok
-lofi fruits music gangsta's paradise free download
-gangster paradise lofi karaoke
-gangsta's paradise lofi fruits music chill fruits music song
-gangster paradise lofi saxophone
-lofi fruits music gangsta's paradise album
-gangster paradise lofi 1 hour
-lofiline & mr cat gangsta's paradise spotify
-gangster paradise lofi flute
-gangsta's paradise lofi fruits music chill fruits music mp3
-gangster paradise lofi ringtone
-lofi fruits music gangsta's paradise genre
-gangster paradise lofi bass boosted
-lofiline & mr cat gangsta's paradise soundcloud
-gangster paradise lofi violin
-gangsta's paradise lofi fruits music chill fruits music video
-gangster paradise lofi trap remix
-lofi fruits music gangsta's paradise release date
-gangster paradise lofi nightcore
-lofiline & mr cat gangsta's paradise lyrics
-gangster paradise lofi jazz remix
-gangsta's paradise lofi fruits music chill fruits music online
-gangster paradise lofi anime amv
-lofi fruits music gangsta's paradise review
-gangster paradise lofi ukulele chords
-lofiline & mr cat gangsta's paradise download
-gangster paradise lofi edm remix
-gangsta's paradise lofi fruits music chill fruits music stream
-gangster paradise lofi meme edit
-lofiline & mr cat - Gangsta's Paradise - Lofi Version (Official Video)
-
-
- [Still D.R.E. (Lofi Remix) by Lofi Fruits Music](https://www.youtube.com/watch?v=0FZ9x8lQq9w) -
- [Juicy (Lofi Remix) by Lofiline](https://www.youtube.com/watch?v=Zy0gXnY6dMw) -
- [Changes (Lofi Remix) by Chill Fruits Music](https://www.youtube.com/watch?v=8JtWfYcQOaA) -
- [Lose Yourself (Lofi Remix) by Future Λ Ready](https://www.youtube.com/watch?v=0v7XyWmzT9k) -
How can I make my own lo-fi music at home?
-You can make your own lo-fi music at home using some simple tools and techniques. Here are some steps to follow:
--
-
- Choose a music software that allows you to create beats and loops. Some examples are FL Studio, Ableton Live, GarageBand, or Audacity. -
- Find some samples or sounds that you want to use for your lo-fi track. You can use your own recordings, or download some from online sources such as Looperman, Splice, or YouTube. -
- Load your samples or sounds into your music software and arrange them into a pattern or sequence. You can use the piano roll or the step sequencer to do this. -
- Add some effects to your track to give it a lo-fi feel. Some common effects are EQ, compression, reverb, delay, distortion, or vinyl simulation. -
- Export your track as an audio file and share it with others online or offline. -
What are some benefits of listening to lo-fi music while studying or working?
-Some benefits of listening to lo-fi music while studying or working are:
--
-
- Lo-fi music can help you relax and reduce stress by creating a calm and soothing atmosphere. -
- Lo-fi music can help you focus and improve your concentration by blocking out distractions and providing a steady background noise. -
- Lo-fi music can help you boost your mood and motivation by stimulating your brain and releasing dopamine. -
- Lo-fi music can help you enhance your creativity and memory by activating different parts of your brain and stimulating neural connections. -
Where can I find more lo-fi music online?
-You can find more lo-fi music online on various platforms and channels that specialize in lo-fi music. Some examples are:
--
-
- [YouTube](https://www.youtube.com/): YouTube is one of the most popular and accessible platforms for lo-fi music. You can find many lo-fi music channels, playlists, and live streams on YouTube, such as [ChilledCow](https://www.youtube.com/channel/UCSJ4gkVC6NrvII8umztf0Ow), [Lofi Girl](https://www.youtube.com/channel/UCqGzJ0YixYjxhVHYCQcixEA), [Lofi Fruits Music](https://www.youtube.com/channel/UC8uJaXvHjsq3TCxa_3XsRrw), and [Lofiline](https://www.youtube.com/channel/UC2m4Z7f9w7oJyK1l1t9yQDw). -
- [Spotify](https://www.spotify.com/): Spotify is one of the most popular and versatile platforms for lo-fi music. You can find many lo-fi music artists, albums, playlists, and podcasts on Spotify, such as [Chillhop Music](https://open.spotify.com/artist/6MpczSUmrdLul28bsaMxTe), [Lofi Fruits Music](https://open.spotify.com/artist/5hAMVKYHFyLbGhXteGOWnU), [Lofiline](https://open.spotify.com/artist/6oBm8HB0yfrxUxzD2lmKsQ), and [Lo-Fi Beats](https://open.spotify.com/playlist/37i9dQZF1DWWQRwui0ExPn). -
- [SoundCloud](https://soundcloud.com/): SoundCloud is one of the most popular and creative platforms for lo-fi music. You can find many lo-fi music artists, tracks, groups, and stations on SoundCloud, such as [Chillhop Music](https://soundcloud.com/chillhopdotcom), [Lofi Fruits Music](https://soundcloud.com/lofi-fruits-music), [Lofiline](https://soundcloud.com/lofiline), and [Lo-Fi Hip Hop Radio](https://soundcloud.com/stations/track/chillhopdotcom/chillhop-raw-cuts-2-full-album). -
Who are some of the most popular lo-fi artists today?
-Some of the most popular lo-fi artists today are:
--
-
- [Jinsang](https://open.spotify.com/artist/5FsfZfRtrtXwNn2JYDeaC5): Jinsang is a lo-fi producer from California who creates smooth and soulful beats with influences from jazz, hip hop, and R&B. Some of his popular songs are [Solitude](https://open.spotify.com/track/4ksgWk9duoHjppnWhRfXsj), [Affection](https://open.spotify.com/track/1rZuEht4txBRmWtZdi2qOL), and [Summer's Day v2](https://open.spotify.com/track/6xGlprv9fmlMj2NhdxNH1C). -
- [Idealism](https://open.spotify.com/artist/6YJ4EgQzDfJnIHRbqIHAdD): Idealism is a lo-fi producer from Germany who creates warm and cozy beats with influences from jazz, hip hop, and ambient. Some of his popular songs are [Controlla](https://open.spotify.com/track/7fRrTyKvE4Skh93v97gtcU), [Hiraeth](https://open.spotify.com/track/3ZffCQKLFLUvYM59XKLbVm), and [Another Perspective](https://open.spotify.com/track/5Sf3GyLEAzJXxZ5mbCPXTu). -
- [Tomppabeats](https://open.spotify.com/artist/0F0MA0ns8oXwGw66B2BSXm): Tomppabeats is a lo-fi producer from Finland who creates nostalgic and dreamy beats with influences from jazz, hip hop, and anime. Some of his popular songs are [U Love](https://open.spotify.com/track/29bIdrNpAToAoznOgNdnGg), [Far Away](https://open.spotify.com/track/7lZauDnRoAC3kmaYae2opv), and [Harbor LP](https://open.spotify.com/album/7x8dCjCr0x6x2lXK HkRnB4). -
-
-
\ No newline at end of file diff --git a/spaces/congsaPfin/Manga-OCR/logs/How to Install Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK Data on Your Phone.md b/spaces/congsaPfin/Manga-OCR/logs/How to Install Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK Data on Your Phone.md deleted file mode 100644 index d273cc869d7e90da882f5e46853f06ee1e085330..0000000000000000000000000000000000000000 --- a/spaces/congsaPfin/Manga-OCR/logs/How to Install Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK Data on Your Phone.md +++ /dev/null @@ -1,84 +0,0 @@ - -
Download Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data
-If you are a fan of first-person shooter games, you might have heard of Modern Combat 5 Blackout, one of the most popular and thrilling games in this genre. But did you know that you can download a mod version of this game that allows you to play offline and enjoy unlimited money and credits? In this article, we will tell you everything you need to know about Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data, including its features and how to download and install it on your Android device.
-download modern combat 5 blackout mod (offline) v1.3.1a apk + data
Download Zip ✅ https://urlca.com/2uOelN
-
Introduction
-What is Modern Combat 5 Blackout?
-Modern Combat 5 Blackout is a first-person shooter game developed by Gameloft and released in 2014. It is the fifth installment in the Modern Combat series, which is inspired by the Call of Duty franchise. The game features a single-player campaign that follows the story of Caydan Phoenix, a former soldier who is involved in a global conspiracy, as well as a multiplayer mode that allows you to compete with other players online in various modes and maps.
-Why download the mod version?
-While Modern Combat 5 Blackout is a free-to-play game, it requires an internet connection to play and has in-app purchases that can enhance your gameplay experience. However, if you want to play offline or enjoy unlimited money and credits without spending real money, you can download the mod version of this game, which has been modified by third-party developers to unlock these features. The mod version also has some other benefits, such as improved performance and bug fixes.
-Features of Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data
-Unlimited money and credits
-One of the main features of Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data is that it gives you unlimited money and credits, which are the two currencies used in the game. You can use them to buy new weapons, armor, skills, and items that can help you in your missions. You can also upgrade your weapons and armor to make them more powerful and durable.
-Offline mode
-Another feature of Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data is that it allows you to play offline, without needing an internet connection. This means that you can enjoy the game anytime and anywhere, without worrying about data usage or connection issues. You can also play the single-player campaign without any interruptions or ads.
-High-quality graphics and sound
-Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data also maintains the high-quality graphics and sound of the original game, which make it one of the best-looking and sounding games on mobile devices. The game features realistic environments, detailed characters, stunning effects, and immersive soundtracks that will make you feel like you are in the middle of a war zone.
-Customizable controls and loadouts
-Another feature of Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data is that it allows you to customize your controls and loadouts according to your preferences and playstyle. You can choose from different control schemes, such as auto-shoot, virtual joystick, or gyroscope, and adjust the sensitivity and layout of the buttons. You can also create your own loadouts by selecting from different classes, weapons, attachments, skills, and items that suit your strategy and tactics.
-Multiplayer and solo modes
-Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data also offers you the option to play either multiplayer or solo modes, depending on your mood and preference. You can join or create online matches with other players around the world in various modes, such as team deathmatch, free-for-all, capture the flag, and more. You can also chat with your teammates and friends using the in-game voice chat feature. Alternatively, you can play solo missions that challenge your skills and reflexes in different scenarios and difficulties.
-How to download and install Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data
-Step 1: Download the APK and data files
-The first step to download and install Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data is to download the APK and data files from a reliable source. You can use the link below to download them directly to your device or computer.
-How to download modern combat 5 blackout offline mod apk + data for free
-Modern combat 5 blackout mod apk + data v1.3.1a offline download link
-Modern combat 5 blackout offline mod apk + data latest version download
-Download modern combat 5 blackout mod apk + data offline mode for android
-Modern combat 5 blackout mod apk + data offline gameplay download
-Modern combat 5 blackout v1.3.1a offline mod apk + data download no root
-Modern combat 5 blackout offline mod apk + data full version download
-Download modern combat 5 blackout mod apk + data offline unlimited money
-Modern combat 5 blackout mod apk + data offline hack download
-Download modern combat 5 blackout mod apk + data offline highly compressed
-Modern combat 5 blackout mod apk + data offline installation guide
-Download modern combat 5 blackout mod apk + data offline without internet
-Modern combat 5 blackout mod apk + data offline features and reviews
-Download modern combat 5 blackout mod apk + data offline update
-Modern combat 5 blackout mod apk + data offline requirements and compatibility
-Download modern combat 5 blackout mod apk + data offline from apkpure
-Modern combat 5 blackout mod apk + data offline best settings and tips
-Download modern combat 5 blackout mod apk + data offline for pc
-Modern combat 5 blackout mod apk + data offline cheats and tricks
-Download modern combat 5 blackout mod apk + data offline from mediafire
-Modern combat 5 blackout mod apk + data offline multiplayer mode download
-Download modern combat 5 blackout mod apk + data offline for ios
-Modern combat 5 blackout mod apk + data offline graphics and sound quality
-Download modern combat 5 blackout mod apk + data offline from google drive
-Modern combat 5 blackout mod apk + data offline missions and challenges download
-Download modern combat 5 blackout mod apk + data offline for windows phone
-Modern combat 5 blackout mod apk + data offline weapons and skins download
-Download modern combat 5 blackout mod apk + data offline from mega.nz
-Modern combat 5 blackout mod apk + data offline bugs and fixes download
-Download modern combat 5 blackout mod apk + data offline for mac
-Modern combat 5 blackout mod apk + data offline maps and locations download
-Download modern combat 5 blackout mod apk + data offline from uptodown
-Modern combat 5 blackout mod apk + data offline ranking and rewards download
-Download modern combat 5 blackout mod apk + data offline for linux
-Modern combat 5 blackout mod apk + data offline customization and options download
Download Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data
-Step 2: Enable unknown sources on your device
-The next step is to enable unknown sources on your device, which will allow you to install apps from sources other than the Google Play Store. To do this, go to your device's settings, then security, then unknown sources, and toggle it on.
-Step 3: Install the APK file
-After enabling unknown sources, you can install the APK file by tapping on it and following the instructions on the screen. It may take a few minutes for the installation to complete.
-Step 4: Extract and copy the data folder to your device's storage
-The next step is to extract and copy the data folder to your device's storage. To do this, you will need a file manager app that can extract zip files, such as ES File Explorer or ZArchiver. Open the file manager app and locate the zip file that contains the data folder. Extract it and copy the folder named "com.gameloft.android.ANMP.GloftM5HM" to your device's storage, under the path "Android/obb". Make sure that the folder is in the correct location before proceeding.
-Step 5: Launch the game and enjoy
-The final step is to launch the game and enjoy playing Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data on your device. You can access all the features of the mod version without any limitations or restrictions.
-Conclusion
-In conclusion, Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data is a great way to experience one of the best first-person shooter games on mobile devices with enhanced features and performance. You can download and install it easily by following the steps above and enjoy playing offline with unlimited money and credits. If you are looking for a thrilling and action-packed game that will keep you entertained for hours, you should definitely try Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data.
-FAQs
--
-
- Is Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data safe to download and install? -
- Will Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data work on my device? -
- Can I play Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data with my friends? -
- Will I get banned for using Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data? -
- Can I update Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data? -
Yes, Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data is safe to download and install as long as you use a trusted source and follow the instructions carefully. However, you should always be careful when downloading apps from unknown sources and scan them for viruses or malware before installing them.
-Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data should work on most Android devices that have at least 2 GB of RAM and Android 4.0 or higher. However, some devices may not be compatible or may experience some issues due to different specifications or settings. You can check the compatibility of your device by visiting the Google Play Store page of the original game and seeing if it is supported.
-Yes, you can play Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data with your friends online in the multiplayer mode. However, you may not be able to join the same matches or servers as players who are using the original version of the game, as they may have different versions or updates. You can also invite your friends to play with you in the solo mode by using the co-op feature.
-There is a possibility that you may get banned for using Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data, as it is not an official version of the game and may violate the terms and conditions of Gameloft. However, this is unlikely to happen if you play offline and do not use any cheats or hacks that may affect the gameplay or give you an unfair advantage over other players. You should also avoid logging in with your social media accounts or Google Play Games account, as they may detect that you are using a modded version of the game.
-No, you cannot update Modern Combat 5 Blackout Mod (Offline) v1.3.1a APK + Data, as it is not connected to the official servers of Gameloft and may not receive any updates or patches from them. If you want to update the game, you will have to download and install a newer version of the mod or switch back to the original version of the game from the Google Play Store.
--
-
\ No newline at end of file diff --git a/spaces/congsaPfin/Manga-OCR/logs/Stick War Legacy - Control Your Stickmen in a War for Peace and Knowledge.md b/spaces/congsaPfin/Manga-OCR/logs/Stick War Legacy - Control Your Stickmen in a War for Peace and Knowledge.md deleted file mode 100644 index b4ef4ca3ba004db634693c46b3569dc0ccb8a65b..0000000000000000000000000000000000000000 --- a/spaces/congsaPfin/Manga-OCR/logs/Stick War Legacy - Control Your Stickmen in a War for Peace and Knowledge.md +++ /dev/null @@ -1,96 +0,0 @@ -
-
Stickman War Legacy: A Fun and Challenging Strategy Game
-If you are looking for a game that combines strategy, action, and stick figures, then you should try Stickman War Legacy. This game is a remake of the original Stick War, one of the most popular and highest rated web games of all time. In this game, you can control your army of stickmen in various ways, build units, mine gold, learn new skills, and fight against different enemies. You can also choose from different game modes, such as classic campaign, endless deads, tournament, missions, and more. In this article, we will tell you more about what Stickman War Legacy is, how to play it, and why you should play it.
-What is Stickman War Legacy?
-A remake of the original Stick War game
-Stickman War Legacy is a mobile game published by Max Games Studios in 2016. It is a remake of the original Stick War game that was released in 2009 in Flash. The original game was created by Jason Whitham and Brock White, who also made other stick figure games such as Stick RPG and Territory War. The original game was praised for its gameplay, graphics, sound effects, and humor. It also had a sequel called Stick War 2: Order Empire in 2012.
-stickman war legacy
Download File ➡ https://urlca.com/2uO96G
-
A mobile game with multiple modes and features
-Stickman War Legacy is available for iOS and Android devices. It has several modes and features that make it more fun and diverse than the original game. For example, it has a missions mode where new levels are released every Friday. It also has a saga style map with multiple rewards. You can also unlock crowns for each difficulty level: normal, hard, and insane. Moreover, you can unlock skins for all characters and weapons for each class. You can also customize your own avatar with different hats, faces, hair styles, and colors.
-A game with stick figure graphics and animations
-One of the most distinctive aspects of Stickman War Legacy is its graphics and animations. The game uses simple but colorful stick figure drawings to represent the characters, units, buildings, weapons, and environments. The game also has smooth and realistic animations for the movements, attacks, deaths, and blood effects of the stickmen. The game also has sound effects and voice overs that add to the atmosphere and humor of the game.
-How to play Stickman War Legacy?
-Choose your difficulty level and nation
-The game starts with a tutorial that teaches you the basics of the game. You can choose your difficulty level from easy to insane. You can also choose your nation from four options: Order (peaceful and balanced), Chaos (aggressive and chaotic), Elemental (magical and elemental), or 3rd Party (neutral and diverse). Each nation has its own unique units, skills, strengths, and weaknesses.
-Control your army and units in different ways
-You can control your army in formations or play each unit individually. You can use the buttons on the screen to move left or right, attack, defend, mine gold, build units, or cast spells. You can also tap on a unit to select it or drag it to move it around. You can also use gestures to zoom in or out or rotate the camera angle.
-Build units, mine gold, and learn new skills
-You need to build units to
fight against the enemy army. You can build different types of units, such as miners, swordwrath, spearton, archidon, magikill, or giants. Each unit has its own cost, speed, health, damage, and range. You need to mine gold from the gold mines to afford the units. You can also learn new skills from the skill tree, such as faster mining, stronger attacks, or special abilities.
-stickman war legacy game
-stickman war legacy download
-stickman war legacy mod apk
-stickman war legacy cheats
-stickman war legacy hack
-stickman war legacy online
-stickman war legacy skins
-stickman war legacy pc
-stickman war legacy tips
-stickman war legacy strategy
-stickman war legacy walkthrough
-stickman war legacy missions
-stickman war legacy zombies
-stickman war legacy tournament
-stickman war legacy crown of inamorta
-stickman war legacy max games studios
-stickman war legacy play store
-stickman war legacy app store
-stickman war legacy ios
-stickman war legacy android
-stickman war legacy review
-stickman war legacy rating
-stickman war legacy wiki
-stickman war legacy fandom
-stickman war legacy units
-stickman war legacy archers
-stickman war legacy swordsmen
-stickman war legacy mages
-stickman war legacy spearmen
-stickman war legacy giants
-stickman war legacy miner
-stickman war legacy statue
-stickman war legacy gold
-stickman war legacy gems
-stickman war legacy spells
-stickman war legacy shop
-stickman war legacy update
-stickman war legacy new features
-stickman war legacy trailer
-stickman war legacy gameplay
-stickman war legacy graphics
-stickman war legacy sound effects
-stickman war legacy music
-stickman war legacy controls
-stickman war legacy difficulty levels
-stickman war legacy achievements
-stickman war legacy leaderboard
-stickman war legacy multiplayer mode (not yet available)
-stickman war legacy fan art (not yet available)
Destroy the enemy statue and capture territories
-The main objective of the game is to destroy the enemy statue before they destroy yours. You need to use your strategy and tactics to overcome the enemy defenses and units. You can also capture territories by destroying the towers and flags in each region. Capturing territories will give you more gold and resources. You can also unlock new units and skills by capturing territories.
-Why play Stickman War Legacy?
-It is fun, challenging, and addicting
-Stickman War Legacy is a game that will keep you entertained for hours. It is fun to control your stickmen army and watch them fight in epic battles. It is challenging to face different enemies and scenarios that require different strategies and skills. It is addicting to progress through the game and unlock new units, skills, skins, and modes.
-It has a variety of game types and levels
-Stickman War Legacy has a lot of content and replay value. It has a classic campaign mode where you can play through 40 levels with different nations and difficulties. It also has an endless deads mode where you can survive waves of zombies and skeletons. It also has a tournament mode where you can compete against other players online. It also has a missions mode where you can complete weekly challenges and earn rewards.
-It has a classic strategy war game style
-Stickman War Legacy is a game that pays homage to the classic strategy war games of the past. It has a simple but effective gameplay that requires you to manage your resources, build your army, and plan your attacks. It also has a retro style graphics and sound effects that create a nostalgic atmosphere. It also has a humorous tone that makes fun of the stick figure genre and war games in general.
-It has a loyal fan base and community
-Stickman War Legacy is a game that has a loyal fan base and community. The game has over 100 million downloads on Google Play Store and over 4 million ratings with an average of 4.5 stars. The game also has an active community on social media platforms such as Facebook, YouTube, Instagram, and Discord. The fans share their gameplay videos, tips, tricks, fan art, memes, and feedback with each other.
-Conclusion
-Stickman War Legacy is a fun and challenging strategy game that you should try if you like stick figure games or war games in general. You can control your army of stickmen in various ways, build units, mine gold, learn new skills, and fight against different enemies. You can also choose from different game modes, such as classic campaign, endless deads, tournament, missions, and more. The game also has stick figure graphics and animations, sound effects and voice overs, humor and nostalgia, and a loyal fan base and community. You can download Stickman War Legacy for free on iOS or Android devices and enjoy this amazing game.
-Frequently Asked Questions
--
-
- How do I unlock new units and skills? -
- How do I change my nation or difficulty level? -
- How do I customize my avatar or use skins? -
- How do I play online with other players? -
- How do I contact the developers or give feedback? -
You can unlock new units and skills by capturing territories in the campaign mode or by completing missions in the missions mode.
-You can change your nation or difficulty level by tapping on the settings icon on the top right corner of the screen.
-You can customize your avatar or use skins by tapping on the avatar icon on the top left corner of the screen.
-You can play online with other players by tapping on the tournament icon on the bottom right corner of the screen.
-You can contact the developers or give feedback by tapping on the support icon on the bottom left corner of the screen.
--
-
\ No newline at end of file diff --git a/spaces/congsaPfin/Manga-OCR/logs/Stumble Guys 3.8 A Fast-Paced Knockout Game with Amazing Graphics and Physics.md b/spaces/congsaPfin/Manga-OCR/logs/Stumble Guys 3.8 A Fast-Paced Knockout Game with Amazing Graphics and Physics.md deleted file mode 100644 index 6f29cce4030f89009f743e94461e982e9ba92242..0000000000000000000000000000000000000000 --- a/spaces/congsaPfin/Manga-OCR/logs/Stumble Guys 3.8 A Fast-Paced Knockout Game with Amazing Graphics and Physics.md +++ /dev/null @@ -1,99 +0,0 @@ -
-
How to Download Stumble Guys 3.8 - The Ultimate Knockout Game
-Do you love playing party games with your friends? Do you enjoy racing through chaotic obstacle courses with up to 32 players online? Do you want to have a lot of fun and laughs while stumbling through different levels until one victor is crowned? If you answered yes to any of these questions, then you should definitely download Stumble Guys 3.8 - the ultimate knockout game!
-What is Stumble Guys 3.8?
-Stumble Guys is a massive multiplayer party knockout game that was released in October 2021 by Scopely. It is inspired by popular TV shows like Wipeout and Takeshi's Castle, where contestants have to overcome various physical challenges and eliminate their rivals. The game is available for both PC and mobile devices, and it supports online and offline modes. You can play with your friends or with strangers from all over the world, and you can customize your character with different outfits and emotes. The game is constantly updated with new maps, obstacles, events, and challenges to keep you entertained and challenged.
-download stumble guys 3.8
Download Zip ⇒ https://urlca.com/2uO6TU
-
Why Download Stumble Guys 3.8?
-Stumble Guys 3.8 is the latest version of the game that was released in June 2023. It brings a lot of new features and improvements that make the game even more fun and exciting. Here are some of the reasons why you should download Stumble Guys 3.8:
-New Maps and Obstacles
-Stumble Guys 3.8 introduces six new maps that will test your skills and reflexes in different ways. You will have to navigate through slippery ice, bouncy balls, spinning blades, swinging hammers, flying rockets, and more. Each map has its own theme and style, such as winter wonderland, candy land, medieval castle, space station, pirate ship, and jungle temple. You will never get bored of playing the same map over and over again.
-New Outfits and Emotes
-Stumble Guys 3.8 also adds more than 50 new outfits and emotes that you can use to customize your character and express yourself. You can dress up as a ninja, a cowboy, a superhero, a clown, a robot, a dinosaur, and many more. You can also use different emotes to taunt your opponents, celebrate your victories, or show your frustration. You can unlock these outfits and emotes by playing the game, completing challenges, or buying them with coins or gems.
-New Events and Challenges
-Stumble Guys 3.8 also brings new events and challenges that will keep you engaged and motivated. You can participate in seasonal events that offer special rewards and bonuses, such as Halloween, Christmas, Valentine's Day, Easter, etc. You can also take on daily and weekly challenges that will test your abilities and give you extra coins or gems. You can also join tournaments that will pit you against the best players in the world and give you a chance to win exclusive prizes.
-How to Download Stumble Guys 3.8 for PC?
-If you want to play Stumble Guys 3.8 on your PC, you will need to download it from Steam, which is a digital distribution platform for games. Here are the steps to download Stumble Guys 3.8 for PC:
--
-
- Create a Steam account if you don't have one already. -
- Download and install the Steam client on your PC. -
- Launch the Steam client and log in with your account. -
- Search for Stumble Guys in the Steam store or click on this link. -
- Click on the Add to Cart button and proceed to checkout. -
- Pay for the game using your preferred payment method. -
- Wait for the game to download and install on your PC. -
- Launch the game from your Steam library and enjoy! -
How to Download Stumble Guys 3.8 for Mobile?
-If you want to play Stumble Guys 3.8 on your mobile device, you will need to download it from Google Play if you have an Android device or from App Store if you have an iOS device. Here are the steps to download Stumble Guys 3.8 for mobile:
--
-
- Open Google Play or App Store on your device. -
- Search for Stumble Guys or click on this link for Android or this link for iOS. -
- Tap on the Install button and wait for the game to download and install on your device. -
- Launch the game from your home screen or app drawer and enjoy! -
How to Play Stumble Guys 3.8?
-Stumble Guys 3.8 is very easy to play but hard to master. You can play online or offline with friends or strangers in different modes. Here is a brief overview of how to play Stumble Guys 3.8:
-Online Mode
-In online mode, you can join or create online matches with up to 32 players from all over the world. You can choose from different maps and settings, such as round limit, time limit, elimination mode, etc. You can also chat with other players using text or voice messages. The goal is to survive as long as possible and reach the finish line before the others. The last player standing wins the match.
-How to download stumble guys 3.8 on steam
-Stumble guys 3.8 free download for android
-Stumble guys 3.8 update features and tips
-Stumble guys 3.8 web store exclusive deals
-Stumble guys 3.8 gameplay and review
-Download stumble guys 3.8 and join the party
-Stumble guys 3.8 best outfits and emotes
-Stumble guys 3.8 online multiplayer mode
-Stumble guys 3.8 map shortcuts and skips
-Stumble guys 3.8 vs fall guys comparison
-Download stumble guys 3.8 and play with friends
-Stumble guys 3.8 latest news and events
-Stumble guys 3.8 system requirements and compatibility
-Stumble guys 3.8 funniest fails and moments
-Stumble guys 3.8 first-person stumbling guide
-Download stumble guys 3.8 and win the crown
-Stumble guys 3.8 super punch and kick tips
-Stumble guys 3.8 hot wheels hustle tips
-Stumble guys 3.8 wild, wacky, and delicious update
-Stumble guys 3.8 community stream and discord
-Download stumble guys 3.8 for windows 10
-Stumble guys 3.8 how to practice and improve
-Stumble guys 3.8 physics-based havoc and chaos
-Stumble guys 3.8 official card collection
-Stumble guys 3.8 user reviews and ratings
-Download stumble guys 3.8 mod apk unlimited money
-Stumble guys 3.8 how to report a bug or issue
-Stumble guys 3.8 colorful, whacky design
-Stumble guys 3.8 meet prob, expert runs
-Stumble guys 3.8 terms of service and privacy policy
Party Mode
-In party mode, you can invite or join friends in private matches. You can create a party code and share it with your friends, or enter a party code that your friends have created. You can also use the friend list feature to see who is online and invite them directly. You can customize the match settings, such as map selection, round limit, time limit, etc. You can also chat with your friends using text or voice messages. The goal is to have fun and compete with your friends in a friendly way.
-Offline Mode
-In offline mode, you can play solo or local multiplayer in offline matches. You can choose from different maps and settings, such as round limit, time limit, elimination mode, etc. You can also adjust the difficulty level of the bots, from easy to hard. You can play alone against bots, or with up to three other players on the same device using split-screen mode. The goal is to practice your skills and enjoy the game without internet connection.
-Tips and Tricks for Stumble Guys 3.8
-Stumble Guys 3.8 is a game that requires both luck and skill. You will need to be fast, agile, smart, and sometimes ruthless to win the matches. Here are some tips and tricks that will help you improve your performance and have more fun in Stumble Guys 3.8:
-Map Shortcuts
-Some maps have shortcuts that you can use to gain an advantage over your opponents. These shortcuts can save you time, avoid obstacles, or give you a boost. However, they are also risky and sometimes hard to find. Here is a table showing some map shortcuts and how to use them:
- | Map | Shortcut | How to Use | | --- | --- | --- | | Winter Wonderland | Ice Slide | Jump on the ice slide near the start of the map and slide down to the next checkpoint | | Candy Land | Donut Hole | Jump through the hole in the giant donut near the end of the map and land on the finish line | | Medieval Castle | Catapult | Jump on the catapult near the middle of the map and launch yourself over the wall to the next checkpoint | | Space Station | Rocket Boost | Jump on the rocket near the start of the map and fly over the first obstacle | | Pirate Ship | Cannon | Jump into the cannon near the end of the map and shoot yourself to the finish line | | Jungle Temple | Vine Swing | Grab the vine near the start of the map and swing over the pit to the next checkpoint |Outfit Customization
-You can customize your outfit by changing your head, body, feet, and color. You can unlock more outfit options by playing the game, completing challenges, or buying them with coins or gems. You can also mix and match different outfit parts to create your own unique style. For example, you can wear a ninja head, a superhero body, a clown feet, and a purple color. You can also change your outfit before each match to suit your mood or theme.
-Emote Usage
-You can use emotes to communicate with other players in a fun and expressive way. You can use emotes to taunt your opponents, celebrate your victories, or show your frustration. You can unlock more emotes by playing the game, completing challenges, or buying them with coins or gems. You can also choose which emotes to equip before each match from your emote wheel. You can use emotes at any time during the match by tapping on the emote button on your screen.
-Conclusion
-Stumble Guys 3.8 is a hilarious and addictive party knockout game that you can play with your friends or with strangers online or offline. It is a game that will make you laugh, scream, rage, and cheer as you stumble through different maps and obstacles until one winner is crowned. It is a game that will keep you entertained and challenged with its constant updates and new features. It is a game that you should definitely download and try for yourself.
-So what are you waiting for? Download Stumble Guys 3.8 now and join the ultimate knockout game!
-FAQs
-Here are some frequently asked questions and their answers about Stumble Guys 3.8:
--
-
- Is Stumble Guys 3.8 free to play? -
- Is Stumble Guys 3.8 cross-platform? -
- How many players can play Stumble Guys 3.8? -
- How do I report a bug or a problem in Stumble Guys 3.8? -
- How do I get more information about Stumble Guys 3.8? -
Yes, Stumble Guys 3.8 is free to play on both PC and mobile devices. However, it does have some optional in-app purchases that you can use to buy coins or gems, which can be used to unlock more outfits and emotes. You can also earn coins or gems by playing the game or completing challenges.
-Yes, Stumble Guys 3.8 is cross-platform, which means that you can play with other players who are using different devices or platforms. For example, you can play with your friends who are using PC, Android, or iOS devices, as long as you are connected to the same online server or party code.
-Stumble Guys 3.8 can support up to 32 players in online mode, which is the maximum number of players that can join or create an online match. In offline mode, you can play solo or with up to three other players on the same device using split-screen mode.
-If you encounter a bug or a problem in Stumble Guys 3.8, you can report it to the developers by using the feedback feature in the game settings. You can also contact them by email at support@scopely.com or by visiting their website at https://www.scopely.com/.
-If you want to get more information about Stumble Guys 3.8, you can visit their official website at https://www.stumbleguys.com/, where you can find more details about the game, its features, its updates, and its community. You can also follow them on social media platforms, such as Facebook, Twitter, Instagram, YouTube, and Discord, where you can get the latest news, updates, tips, and tricks about the game.
--
-
\ No newline at end of file diff --git a/spaces/congsaPfin/Manga-OCR/logs/Violet Messenger A Plugin for Libpurple to Support Facebook Chat.md b/spaces/congsaPfin/Manga-OCR/logs/Violet Messenger A Plugin for Libpurple to Support Facebook Chat.md deleted file mode 100644 index f0a845f06cb42650b9c980820e1bf11d29e5087d..0000000000000000000000000000000000000000 --- a/spaces/congsaPfin/Manga-OCR/logs/Violet Messenger A Plugin for Libpurple to Support Facebook Chat.md +++ /dev/null @@ -1,95 +0,0 @@ - -
Violet Download Messenger: How to Stay Connected with Your Friends and Family
-Do you want to hang out with your favorite people anytime, anywhere? Do you want to enjoy unlimited text, voice, video calling and group video chat features? Do you want to customize your chats, watch videos together, send and receive money, and chat with businesses? If you answered yes to any of these questions, then you need to download Violet Download Messenger, the free all-in-one communication app that makes it easy and fun to stay close to your friends and family.
-violet download messenger
Download Zip ○ https://urlca.com/2uO9LQ
-
What is Violet Download Messenger?
-Violet Download Messenger is a messaging and calling app that lets you connect with your Instagram friends right from Messenger. You can simply search for them by name or username to message or call. You can also use the app to chat with your Facebook friends, even if they're across the world. Violet Download Messenger has a sleek new look that darkens the colors of the chat interface, giving your eyes some rest. You can also record and send voice and video messages when text just won't cut it. You can express yourself with custom stickers, GIFs, and emojis, and use effects and filters to video calls. You can also send files, photos, and videos with no limit, and plan and make things happen with polls and location sharing. You can even send and request money securely and quickly right in the app, or chat with businesses to make reservations, get customer support, find deals and more.
-Why should you use Violet Download Messenger?
-Violet Download Messenger has many benefits that make it a great choice for communication and socializing. Here are some of them:
-Cross-app messaging and calling
-You can connect with your Instagram friends right from Messenger. You don't need to switch between apps or create new accounts. You can also chat with your Facebook friends on the same platform.
-Privacy and safety settings
-You can choose who can reach you, and where your messages are delivered. You can also block or report anyone who makes you feel uncomfortable or unsafe.
-Custom reactions and chat themes
-You can customize your reactions, with lots more emojis to choose from. You can also choose from fun themes and colors, like Tie-Dye or Love, to make your chats more personal.
-How to download violet messenger app for free
-Violet messenger vs Facebook messenger: which one is better?
-Violet messenger features and benefits
-Download violet messenger for iPhone, iPad, and iPod touch
-Violet messenger review: pros and cons
-How to use violet messenger for video calling and group chat
-Violet messenger privacy and security settings
-How to install violet messenger plugin for libpurple
-Violet messenger alternatives and competitors
-How to delete violet messenger account and data
-How to troubleshoot violet messenger issues and errors
-Violet messenger customer service and support
-How to customize violet messenger with themes and stickers
-Violet messenger tips and tricks
-How to invite friends to join violet messenger
-How to backup and restore violet messenger chats
-Violet messenger integration with other apps and services
-How to update violet messenger to the latest version
-Violet messenger user guide and tutorial
-How to make money with violet messenger
-How to use violet messenger for business and marketing
-Violet messenger statistics and trends
-How to access violet messenger on desktop and web
-Violet messenger feedback and suggestions
-How to report violet messenger bugs and problems
-How to block and unblock violet messenger contacts
-Violet messenger notifications and sounds settings
-How to mute and unmute violet messenger conversations
-Violet messenger emojis and GIFs
-How to share files and photos on violet messenger
-How to create and join groups on violet messenger
-Violet messenger voice messages and calls
-How to change your name and profile picture on violet messenger
-Violet messenger status and stories
-How to sync violet messenger across devices
-How to use violet messenger in dark mode
-Violet messenger fun facts and trivia
-How to delete messages and chats on violet messenger
-Violet messenger history and development
-How to use violet messenger offline mode
Watch together and group video chat
-You can watch videos, tv shows, and movies with your friends over Messenger Video Chat and Rooms when you can't be together. You can capture every moment and reaction in real-time.
-Unlimited free text and phone calls
-You can skip exchanging phone numbers and simply send a message to your friends, even if they're across the world. You can enjoy high-quality voice and text messaging on mobile, tablet, and desktop.
-Dark mode and voice and video messages
-You can give your eyes some rest with a sleek new look that darkens the colors of the chat interface. You can also record and send voice and video messages when text just won't cut it.
-Stickers, GIFs, and emojis
-You can express yourself with custom stickers, GIFs, and emojis. You can use them to show your creative side, your mood, or your humor.File, photo, and video sharing -
You can send files, photos, and videos with no limit. You can share memories, documents, and more with your friends and family. You can also preview your media before sending and leave a comment if you want.
-Plan and make it happen
-You can create polls to gather opinions from your group. You can also share your location to let people know where you are or where you're going. You can also create events and invite your friends to join.
-Send and request money with no fees
-You can securely send and request money in the app using your debit card or PayPal account. You don't need to pay any fees, and the money will be transferred instantly.
-Chat with businesses
-You can chat with businesses to get things done. You can make reservations, get customer support, find deals, and more. You can also see and respond to messages from your Facebook Page Inbox.
-How to download and install Violet Download Messenger?
-Downloading and installing Violet Download Messenger is easy and fast. Here are the steps to follow:
--
-
- Go to the Google Play Store or the App Store on your device. -
- Search for "Violet Download Messenger" or click on one of these links: Android or iOS. -
- Tap on "Install" or "Get" and wait for the app to download. -
- Open the app and sign in with your Facebook account or create a new one. -
- Start chatting with your friends and family! -
Conclusion
-Violet Download Messenger is a free all-in-one communication app that lets you stay connected with your friends and family. You can enjoy unlimited text, voice, video calling and group video chat features, as well as customize your chats, watch videos together, send and receive money, and chat with businesses. You can also connect with your Instagram friends right from Messenger, without switching between apps. Violet Download Messenger is easy to download and install on your device, and it has a sleek new look that darkens the colors of the chat interface. If you want to have fun and stay close to your favorite people, download Violet Download Messenger today!
-Frequently Asked Questions
--
-
- Q: Is Violet Download Messenger free? -
- A: Yes, Violet Download Messenger is free to download and use. You don't need to pay any fees or subscriptions to enjoy its features. -
- Q: How do I switch between Facebook Messenger and Instagram chats? -
- A: You can switch between Facebook Messenger and Instagram chats by tapping on the profile picture of the person you're chatting with. You'll see a menu that lets you choose which app you want to use. -
- Q: How do I turn on dark mode on Violet Download Messenger? -
- A: You can turn on dark mode on Violet Download Messenger by tapping on your profile picture in the top left corner of the app. Then, tap on "Theme" and choose "Dark". -
- Q: How do I send money on Violet Download Messenger? -
- A: You can send money on Violet Download Messenger by tapping on the "+" icon in the bottom right corner of the chat. Then, tap on "Pay" and choose a contact or enter an amount. You'll need to link your debit card or PayPal account to use this feature. -
- Q: How do I chat with businesses on Violet Download Messenger? -
- A: You can chat with businesses on Violet Download Messenger by tapping on the search icon in the top right corner of the app. Then, type in the name of the business or browse through the categories. You'll see a list of businesses that you can message or call. -
-
-
\ No newline at end of file diff --git a/spaces/contluForse/HuggingGPT/assets/3d Album Cs 3.32 Crack REPACK.md b/spaces/contluForse/HuggingGPT/assets/3d Album Cs 3.32 Crack REPACK.md deleted file mode 100644 index 8eae343f677e3f1177cf912972549aab76e0045b..0000000000000000000000000000000000000000 --- a/spaces/contluForse/HuggingGPT/assets/3d Album Cs 3.32 Crack REPACK.md +++ /dev/null @@ -1,12 +0,0 @@ - -
download..3D..Album..Commercial..Suite..v3.29..Portableh33traththarantorrent..for..free,..3D..Album..Commercial..Suite..v3.29..Portableh33traththaran..torrent..download....3d....album....commercial....suite....3.3....portable....Free....Download....3d....album....commercial....suite....2012....3d....album....commercial....suite....Free....Download....3d....album....commercial....suite....Serial.3D-Album...CS...-...awesome...program...for...creating...3D...virtual...albums...based...on...your...images...using...built-in...libraries...of...animation...styles....It...is...a...powerful,...professional.....Results...of...3d...album...commercial...suite...3.33...full:...Free...download...software,...Free...Video...dowloads,...Free...Music...downloads,...Free...Movie...downloads,...Games.Vast....selection....of....software.....Free....Shipping....on....Qualified....Orders..3D....Album....Commercial....Suite....3.28/3D....Album....Commercial....Suite....3.28.daa....-....574.04....MB....3D....Album....Commercial....Suite....3.28/3D....Album....Commercial....Suite....3.28.nfo....-....5.22....KB....3D....Album......portable...3d...album...commercial...suite...3...30...lovely...styles...reupload...Software...-...Free...Download...portable...3d...album...commercial...suite...3...30...lovely...styles...reupload...-...Top...4.....3d..Album..Commercial..Suite..3..33..Free..Full..Version..Download..mediafire..links..free..download,..download..3d..Album..Commercial..Suite..3..3..part1,..3D..ALBUM..COMMERCIAL..SUITE..3..0....Download....3D....Album....Commercial....Suite....Torrent.........3D-Album-Portuguese-Pack.exe....[1.50....MB]....3DAlbumCommercialSuite3.29www.softarchive.net.part1.rar....[99.95....MB].3D-Album...Commercial...Suite...3.33...Portable...Full...version...01....3D...Album...Commercial...Suite...3.33...Portable...Full...version.....3d....album....commercial....suite....3.29....download,....CorelDRAW....Graphics....Suite....X3,....FVD....Suite....2.5.1,....MQuiz....Integer....Addition....-....Adding....Positive....and....Negative....Integers....-....Math....Quiz....1.0.Full...Free...Download...of...3D-Album...Commercial...Suite...3.29...which...is...3D-Album...Commercial...Suite...3.29......650...MB...3D-Album...Commercial...Suite...is...the...complete...digital...solution...for.....MidwayUSA....is....a....privately....held....American....retailer....of....various....hunting....and....outdoor-related....products..3D..Album..Commercial..Suite..3.3..3..Complete..Digital..Imaging..Solution..for..Commercial..Production..Are..you..always..hunting..for..an..exciting..way..to..publish..your....3D..Album..Commercial..Suite..3.33-torrent.zip,..the..sirius..documentary..2013..dvd..download..02e8347b40..taleem..e..balighan..InPixio..Photo..Clip..5.0..Professional.rar.3d..album..commercial..suite..3..Software..-..Free..Download..3d..album..commercial..suite..3..-..Top..4..Download..-..Top4Download.com..offers..free..software..downloads..for..Windows,..Mac....3D-Album....Commercial....Suite....is....the....complete....digital....solution....for....professionals.....It....combines....3D-Albums....unique....and....creative....3D....animated....presentation....templates....with......Vast....selection....of....software.....Free....Shipping....on....Qualified....Orders..Free....download....3d....album....commercial....suite....3....33....Files....at....Software....Informer.....Show,....present,....exhibit,....animate,....publish,....walkthrough,....and....even....design....photo....quiz....games..3D....Album....Commercial....Suite....3.33-torrent.zip.3d..album,..commercial..suite..3.3..download,..free..download..3d..album..commercial..suite..3.3..,..photo..managing..software,..best..graphics..&..photo..editor,..full..version..with..crack....3d....Album....Commercial....Suite....3....33....Free....Full....Version....Download....mediafire....links....free....download,....download....3d....Album....Commercial....Suite....3....3....part1,....3D....ALBUM....COMMERCIAL....SUITE....3....0......3D...Album...commercial...suite...by...galedo....Versions:...3.3...and...3.2..Related....software....to....3d....album....commercial....suite....3.30....free....full....version....download.....Showing....:....1....-....10....from....23.....Adobe....Photoshop....Album....Starter....Edition....3.2....Adobe....Photoshop......Vast...selection...of...software....Free...Shipping...on...Qualified...Orders..Download...3d-album-commercial-suite-3.30-free-full-version-download.3D..Album..Commercial..Suite,..free..download...3D..Album..Commercial..Suite..3.0:..Global..Marketing.3D....Album....Commercial....Suite....version....3.0....+....All....Wedding....Beautiful....Styles........1.2GB.....Easily....create....Hollywood-style....photo....showcases....from....100+....(for....Commercial....Suite....and......[Fshare]...3D...Album...Commercial...Suite...v3.33...-...3D...Album...3.33...full...crack...-...Lm...Album...nh...tuyt...p...cho...bn.Home......Download...3D...Album...Commercial...Suite......Download...3D...Album...Commercial...Suite...latest...version......free...full...verion...of...3D...Album...Commercial...Suite......Download...3D...Album.....3D-Album..Commercial..Suite..3.32....1.8..Gb..3D-Album..Commercial..Suite..3.32....1.8..Gb..The..new..version..of..3D-Album..CS..with..a..complete..set..of..styles..?..is..the..best..program..for....3D..Album..Commercial..Suite..3..32..KeyGen..rar..torrent...Information..about..the..torrent..3D..Album..Commercial..Suite..3..32..KeyGen..rar...Seeders,..leechers..and..torrent..status..is....3D..Album..C
-ommercial..Suite..3.32..Multi/Final....1.78..GB..The..new..version..of..3D-Album..CS..with..a..complete..set..of..styles....is..the..best..program..for..creating..3D....download...3d...Album...commercial...Suitetorrent...for...free,...3d...Album...commercial...Suite...torrent...download,...download...3d...Album...commercial...Suite.Torrent....Contents.....3D....Album....Commercial....Suite....v3.29....Portableh33traththaran....Portable....3D....Album....Commercial....Suite....v3.29.........Portable....3D....Album....Commercial....Suite....v3.29.exe......MidwayUSA...is...a...privately...held...American...retailer...of...various...hunting...and...outdoor-related...products..Full..Free..Download..of..3D..Album..Commercial..Suite..3.30..Final..which..is..3D..Album..Commercial..Suite..3.30..Final....1.8..Gb..The..new..version..of..3D-Album..CS..with..a..complete..set...4c5316f046
-3d Album Cs 3.32 Crack
Download File ⭐ https://ssurll.com/2uzycN
-
etabs 9.7.2 portableReadyFor4GB 1.4.raradobe photoshop CS6Extended 13.0.rar password txtGame of Thrones S02E07HDTV.x264-ASAPManual Clinical Surgery S Dasservice manual canonir2520 1m-tek h16106dfg driver win7[PC] Dreams to Reality -ENGHilltop Hoods-Hard Road: Restrung full album zipMavado-GangstaFor Life The Symphony Of David Brooks-RETAiL CD full album zip
-In 1993, Gibson contributed lyrics and featured as a guest vocalist on Yellow Magic Orchestra's Technodon album,[90][91] and wrote lyrics to the track "Dog Star Girl" for Deborah Harry's Debravation.[92]
-Since its debut in 1992, the mystery of Agrippa remained hidden for 20 years. Although many had tried to hack the code and decrypt the program, the uncompiled source code was lost long ago. Alan Liu and his team at "The Agrippa Files"[112] created an extensive website with tools and resources to crack the Agrippa Code. They collaborated with Matthew Kirschenbaum at the Maryland Institute for Technology in the Humanities and the Digital Forensics Lab, and Quinn DuPont, a PhD student of cryptography from the University of Toronto, in calling for the aid of cryptographers to figure out how the program works by creating "Cracking the Agrippa Code: The Challenge",[113] which enlisted participants to solve the intentional scrambling of the poem in exchange for prizes.[114] The code was successfully cracked by Robert Xiao in late July 2012.[113]
-Gibson's work has influenced several popular musicians: references to his fiction appear in the music of Stuart Hamm,[d] Billy Idol,[e] Warren Zevon,[f] Deltron 3030, Straylight Run (whose name is derived from a sequence in Neuromancer)[140] and Sonic Youth. U2's Zooropa album was heavily influenced by Neuromancer,[44] and the band at one point planned to scroll the text of Neuromancer above them on a concert tour, although this did not end up happening. Members of the band did, however, provide background music for the audiobook version of Neuromancer as well as appearing in No Maps for These Territories, a biographical documentary of Gibson.[141] He returned the favour by writing an article about the band's Vertigo Tour for Wired in August 2005.[142] The band Zeromancer take their name from Neuromancer.[143]
- -Neuromancer was written on a "clockwork typewriter," the very one you may recall glimpsing in Julie Deane's office in Chiba City. This machine, a Hermes 2000 manual portable, dates from somewhere in the 1930s. It's a very tough and elegant piece of work, from the factory of E. PAILLARD & Cie S.A. YVERDON (SUISSE). Cased, it weighs slightly less than the Macintosh SE/30 I now write on, and is finished in a curious green- and-black "crackle" paint-job, perhaps meant to suggest the covers of an accountant's ledger. Its keys are green as well, of celluloid, and the letters and symbols on them are canary yellow. (I once happened to brush the shift-key with the tip of a lit cigarette, dramatically confirming the extreme flammability of this early plastic.) In its day, the Hermes 2000 was one of the best portable writing-machines in the world, and one of the most expensive. This one belonged to my wife's step-grandfather, who had been a journalist of sorts and had used it to compose laudatory essays on the poetry of Robert Burns. I used it first to write undergraduate Eng. lit. papers, then my early attempts at short stories, then Neuromancer, all without so much as ever having touched an actual computer.
aaccfb2cb3-
-
\ No newline at end of file diff --git a/spaces/contluForse/HuggingGPT/assets/Avril Lavigne-Lets Go B-Sides Full Album Zip Aereo Dreamweaver Sp.md b/spaces/contluForse/HuggingGPT/assets/Avril Lavigne-Lets Go B-Sides Full Album Zip Aereo Dreamweaver Sp.md deleted file mode 100644 index e06433c92d75cbcc8a38266d0aaf66a0c83244b8..0000000000000000000000000000000000000000 --- a/spaces/contluForse/HuggingGPT/assets/Avril Lavigne-Lets Go B-Sides Full Album Zip Aereo Dreamweaver Sp.md +++ /dev/null @@ -1,6 +0,0 @@ -
Avril Lavigne-Lets Go B-Sides Full Album Zip aereo dreamweaver sp
Download Zip 🗸🗸🗸 https://ssurll.com/2uzvGp
-
- aaccfb2cb3
-
-
- diff --git a/spaces/contluForse/HuggingGPT/assets/BioSolveIT SeeSAR Free Download.md b/spaces/contluForse/HuggingGPT/assets/BioSolveIT SeeSAR Free Download.md deleted file mode 100644 index dbbf846a112da831c4b85a49e9b3f0c11e855446..0000000000000000000000000000000000000000 --- a/spaces/contluForse/HuggingGPT/assets/BioSolveIT SeeSAR Free Download.md +++ /dev/null @@ -1,100 +0,0 @@ - -
BioSolveIT SeeSAR Free Download: A Comprehensive Guide
- -If you are looking for a software tool that can help you design, optimize, and analyze chemical compounds, you may want to check out BioSolveIT SeeSAR. It is a software solution developed by BioSolveIT GmbH, a leading company in the field of cheminformatics and drug discovery. In this article, we will give you a comprehensive guide on how to get BioSolveIT SeeSAR free download and what are its features and benefits.
-BioSolveIT SeeSAR Free Download
DOWNLOAD ––– https://ssurll.com/2uzyd4
- -
What is BioSolveIT SeeSAR?
- -BioSolveIT SeeSAR is a software tool for interactive, visual compound prioritization and compound evolution. It is designed for scientists and researchers in the pharmaceutical, biotech, and chemical industries who want to accelerate their drug discovery process and improve their decision making. BioSolveIT SeeSAR allows users to design and optimize chemical compounds based on various criteria, such as binding affinity, selectivity, solubility, toxicity, and synthesis feasibility. It also allows users to analyze chemical structures and properties, such as molecular weight, logP, hydrogen bonds, rotatable bonds, and pharmacophore features. BioSolveIT SeeSAR also supports predictive modeling and simulation of chemical compounds, such as docking, scoring, superposition, pocket exploration, similarity search, and analog search.
- -BioSolveIT SeeSAR is a user-friendly and intuitive software tool that has a modern and sleek interface. It uses 3D graphics and animations to display chemical compounds and their interactions with targets. It also has a dashboard that shows various information and statistics about the compounds and their optimization progress. Users can easily navigate through the software and perform various tasks with simple mouse clicks and keyboard shortcuts. Users can also collaborate with their team members by sharing their projects and results through email or cloud services.
- -How to Get BioSolveIT SeeSAR Free Download?
- -If you want to get BioSolveIT SeeSAR free download, you have two options: you can either request a free trial or apply for an academic license. Both options require you to register on the BioSolveIT website and provide some basic information about yourself and your organization.
- - -The free trial option allows you to use BioSolveIT SeeSAR for 30 days without any limitations or obligations. You can download the latest version of the software from the BioSolveIT website and install it on your Windows, Linux, or macOS device. You can also access various resources, such as tutorials, guides, videos, webinars, and support forums to help you get started with the software.
- -The academic license option allows you to use BioSolveIT SeeSAR for free if you are a student, teacher, or researcher affiliated with an academic institution. You can download the latest version of the software from the BioSolveIT website and install it on your Windows, Linux, or macOS device. You can also access various resources, such as tutorials, guides, videos, webinars, and support forums to help you get started with the software.
- -What are the Features and Benefits of BioSolveIT SeeSAR?
- -BioSolveIT SeeSAR is a powerful software tool that has many features and benefits for users who want to design, optimize, and analyze chemical compounds. Some of the main features and benefits are:
- --
-
- BioSolveIT SeeSAR allows users to design and optimize chemical compounds based on various criteria, such as binding affinity, selectivity,
-
BioSolveIT SeeSAR Free Download: How to Install and Use the Software
- -Once you have downloaded BioSolveIT SeeSAR from the BioSolveIT website, you can easily install and use the software on your device. Here are the steps to install and use BioSolveIT SeeSAR:
- --
-
- Run the downloaded file and follow the instructions on the screen to complete the installation process. -
- Launch BioSolveIT SeeSAR from your desktop or start menu. -
- Enter your email address and password to log in to the software. If you are using a free trial or an academic license, you will also need to enter your activation code that you received from BioSolveIT. -
- Select a project or create a new one. You can also import or export projects from or to other software tools. -
- Add a target protein or a ligand to your project. You can either load them from a file or from a database, such as PDB or PubChem. -
- Use the various features and tools of BioSolveIT SeeSAR to design, optimize, and analyze your compounds. You can also use the dashboard to view various information and statistics about your compounds and their optimization progress. -
- Save your project and share it with your team members or export it to other software tools. -
If you need any help or guidance on how to use BioSolveIT SeeSAR, you can access various resources, such as tutorials, guides, videos, webinars, and support forums on the BioSolveIT website. You can also contact BioSolveIT GmbH for any technical issues or feedback.
- -BioSolveIT SeeSAR Free Download: The Pros and Cons of the Software
- -BioSolveIT SeeSAR is a software tool that has many pros and cons for users who want to design, optimize, and analyze chemical compounds. Here are some of the pros and cons of BioSolveIT SeeSAR:
- --
-
- Pros:
-
-
-
- BioSolveIT SeeSAR is a user-friendly and intuitive software tool that has a modern and sleek interface. -
- BioSolveIT SeeSAR allows users to design and optimize chemical compounds based on various criteria, such as binding affinity, selectivity,
-
BioSolveIT SeeSAR Free Download: The Pricing and Subscription Plans of the Software
- -BioSolveIT SeeSAR is a software tool that has various pricing and subscription plans for different types of users and organizations. Users can choose the plan that suits their needs and budget. Here are the pricing and subscription plans of BioSolveIT SeeSAR:
- --
-
- Free trial: Users can use BioSolveIT SeeSAR for 30 days without any limitations or obligations. Users can download the latest version of the software from the BioSolveIT website and install it on their Windows, Linux, or macOS device. Users can also access various resources, such as tutorials, guides, videos, webinars, and support forums to help them get started with the software. -
- Academic license: Users who are affiliated with an academic institution can use BioSolveIT SeeSAR for free. Users can download the latest version of the software from the BioSolveIT website and install it on their Windows, Linux, or macOS device. Users can also access various resources, such as tutorials, guides, videos, webinars, and support forums to help them get started with the software. -
- Standard license: Users who want to use BioSolveIT SeeSAR for commercial purposes can purchase a standard license. The standard license costs € 3,000 per year per user and includes all features and updates of the software. Users can also get technical support and customer service from BioSolveIT GmbH. -
- Premium license: Users who want to use BioSolveIT SeeSAR for commercial purposes and also want to customize the software for their specific needs can purchase a premium license. The premium license costs € 5,000 per year per user and includes all features and updates of the software as well as customization options. Users can also get technical support and customer service from BioSolveIT GmbH. -
BioSolveIT SeeSAR Free Download: The Conclusion
- -BioSolveIT SeeSAR is a software tool that can help users design, optimize, and analyze chemical compounds. It is a user-friendly and intuitive software tool that has a modern and sleek interface. It allows users to design and optimize chemical compounds based on various criteria, such as binding affinity, selectivity, -
BioSolveIT SeeSAR Free Download: The Comparison with Other Software Tools
- -BioSolveIT SeeSAR is a software tool that can be compared with other software tools that offer similar or related features and functions. Some of the software tools that can be compared with BioSolveIT SeeSAR are:
- --
-
- MOE: MOE is a software tool developed by Chemical Computing Group that provides a suite of applications for molecular modeling, drug discovery, protein modeling, cheminformatics, and bioinformatics. MOE has features such as docking, scoring, pharmacophore modeling, QSAR, molecular dynamics, and more. -
- Schrödinger: Schrödinger is a software tool developed by Schrödinger LLC that provides a comprehensive platform for computational chemistry and drug discovery. Schrödinger has features such as ligand-based and structure-based design, virtual screening, lead optimization, ADME/Tox prediction, and more. -
- ChemAxon: ChemAxon is a software tool developed by ChemAxon Ltd that provides a range of solutions for cheminformatics and chemical data management. ChemAxon has features such as structure drawing, structure search, property prediction, library design, and more. -
Each of these software tools has its own strengths and weaknesses, and users can choose the one that best suits their needs and preferences. However, some of the advantages that BioSolveIT SeeSAR has over these software tools are:
- --
-
- BioSolveIT SeeSAR is more user-friendly and intuitive than these software tools. It has a modern and sleek interface that uses 3D graphics and animations to display chemical compounds and their interactions with targets. It also has a dashboard that shows various information and statistics about the compounds and their optimization progress. -
- BioSolveIT SeeSAR is more interactive and visual than these software tools. It allows users to design and optimize chemical compounds in a visual and interactive way. Users can easily navigate through the software and perform various tasks with simple mouse clicks and keyboard shortcuts. -
- BioSolveIT SeeSAR is more flexible and customizable than these software tools. It allows users to integrate with other software tools to enhance its functionality and usability. Users can also customize the software for their specific needs by contacting BioSolveIT GmbH. -
BioSolveIT SeeSAR Free Download: The Summary
- -In conclusion, BioSolveIT SeeSAR is a software tool that can help users design, optimize, and analyze chemical compounds. It is a user-friendly and intuitive software tool that has a modern and sleek interface. It allows users to design and optimize chemical compounds based on various criteria, such as binding affinity, selectivity, -
BioSolveIT SeeSAR Free Download: The Conclusion
- -BioSolveIT SeeSAR is a software tool that can help users design, optimize, and analyze chemical compounds. It is a user-friendly and intuitive software tool that has a modern and sleek interface. It allows users to design and optimize chemical compounds based on various criteria, such as binding affinity, selectivity, solubility, toxicity, and synthesis feasibility. It also allows users to analyze chemical structures and properties, such as molecular weight, logP, hydrogen bonds, rotatable bonds, and pharmacophore features. BioSolveIT SeeSAR also supports predictive modeling and simulation of chemical compounds, such as docking, scoring, superposition, pocket exploration, similarity search, and analog search.
- -BioSolveIT SeeSAR is a software tool that can be integrated with other software tools to enhance its functionality and usability. Users can import or export projects from or to other software tools, such as KNIME, PyMOL, MOE, Schrödinger, ChemAxon, and others. Users can also use various components of BioSolveIT SeeSAR, such as HYDE, FlexX, FlexS, FastGrow, FTrees, SpaceLight, and CoLibri, as standalone tools or as plugins for other software tools.
- -BioSolveIT SeeSAR is a software tool that has various pricing and subscription plans for different types of users and organizations. Users can choose the plan that suits their needs and budget. Users can either request a free trial or apply for an academic license to use BioSolveIT SeeSAR for free. Users can also purchase a standard license or a premium license to use BioSolveIT SeeSAR for commercial purposes and also customize the software for their specific needs.
- -BioSolveIT SeeSAR is a software tool that has received positive reviews and testimonials from its customers and users. Users have praised its features and benefits, such as its user-friendliness, interactivity, flexibility, customization options, integration options, and more. Users have also expressed their satisfaction and appreciation of BioSolveIT SeeSAR.
- -BioSolveIT SeeSAR is a software tool that can be compared with other software tools that offer similar or related features and functions. However, BioSolveIT SeeSAR has some advantages over these software tools, such as its user-friendliness,
3cee63e6c2
-
-
\ No newline at end of file diff --git a/spaces/contluForse/HuggingGPT/assets/Download Film Jannat 2 Movie 4 Subtitle Indonesia alphabetisch mittele The Story of Love Betrayal and Redemption.md b/spaces/contluForse/HuggingGPT/assets/Download Film Jannat 2 Movie 4 Subtitle Indonesia alphabetisch mittele The Story of Love Betrayal and Redemption.md deleted file mode 100644 index 31944a01b3fa4e5ad8c22e5a102a8e51987df9ee..0000000000000000000000000000000000000000 --- a/spaces/contluForse/HuggingGPT/assets/Download Film Jannat 2 Movie 4 Subtitle Indonesia alphabetisch mittele The Story of Love Betrayal and Redemption.md +++ /dev/null @@ -1,6 +0,0 @@ -Download Film Jannat 2 Movie 4 Subtitle Indonesia alphabetisch mittele
Download > https://ssurll.com/2uzvYZ
-
- aaccfb2cb3
-
-
- diff --git a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/mmpkg/mmcv/ops/bbox.py b/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/mmpkg/mmcv/ops/bbox.py deleted file mode 100644 index 0c4d58b6c91f652933974f519acd3403a833e906..0000000000000000000000000000000000000000 --- a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/mmpkg/mmcv/ops/bbox.py +++ /dev/null @@ -1,72 +0,0 @@ -# Copyright (c) OpenMMLab. All rights reserved. -from ..utils import ext_loader - -ext_module = ext_loader.load_ext('_ext', ['bbox_overlaps']) - - -def bbox_overlaps(bboxes1, bboxes2, mode='iou', aligned=False, offset=0): - """Calculate overlap between two set of bboxes. - - If ``aligned`` is ``False``, then calculate the ious between each bbox - of bboxes1 and bboxes2, otherwise the ious between each aligned pair of - bboxes1 and bboxes2. - - Args: - bboxes1 (Tensor): shape (m, 4) in[0-9]+)[\r\n]+" - b"#define[ \t]+.*_height[ \t]+(?P [0-9]+)[\r\n]+" - b"(?P " - b"#define[ \t]+[^_]*_x_hot[ \t]+(?P [0-9]+)[\r\n]+" - b"#define[ \t]+[^_]*_y_hot[ \t]+(?P [0-9]+)[\r\n]+" - b")?" - rb"[\000-\377]*_bits\[]" -) - - -def _accept(prefix): - return prefix.lstrip()[:7] == b"#define" - - -## -# Image plugin for X11 bitmaps. - - -class XbmImageFile(ImageFile.ImageFile): - format = "XBM" - format_description = "X11 Bitmap" - - def _open(self): - m = xbm_head.match(self.fp.read(512)) - - if not m: - msg = "not a XBM file" - raise SyntaxError(msg) - - xsize = int(m.group("width")) - ysize = int(m.group("height")) - - if m.group("hotspot"): - self.info["hotspot"] = (int(m.group("xhot")), int(m.group("yhot"))) - - self.mode = "1" - self._size = xsize, ysize - - self.tile = [("xbm", (0, 0) + self.size, m.end(), None)] - - -def _save(im, fp, filename): - if im.mode != "1": - msg = f"cannot write mode {im.mode} as XBM" - raise OSError(msg) - - fp.write(f"#define im_width {im.size[0]}\n".encode("ascii")) - fp.write(f"#define im_height {im.size[1]}\n".encode("ascii")) - - hotspot = im.encoderinfo.get("hotspot") - if hotspot: - fp.write(f"#define im_x_hot {hotspot[0]}\n".encode("ascii")) - fp.write(f"#define im_y_hot {hotspot[1]}\n".encode("ascii")) - - fp.write(b"static char im_bits[] = {\n") - - ImageFile._save(im, fp, [("xbm", (0, 0) + im.size, 0, None)]) - - fp.write(b"};\n") - - -Image.register_open(XbmImageFile.format, XbmImageFile, _accept) -Image.register_save(XbmImageFile.format, _save) - -Image.register_extension(XbmImageFile.format, ".xbm") - -Image.register_mime(XbmImageFile.format, "image/xbm") diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/aiohttp/multipart.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/aiohttp/multipart.py deleted file mode 100644 index 73801f459aa274ca6aae7bf28a2c5bb3bf075d11..0000000000000000000000000000000000000000 --- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/aiohttp/multipart.py +++ /dev/null @@ -1,961 +0,0 @@ -import base64 -import binascii -import json -import re -import uuid -import warnings -import zlib -from collections import deque -from types import TracebackType -from typing import ( - TYPE_CHECKING, - Any, - AsyncIterator, - Deque, - Dict, - Iterator, - List, - Mapping, - Optional, - Sequence, - Tuple, - Type, - Union, - cast, -) -from urllib.parse import parse_qsl, unquote, urlencode - -from multidict import CIMultiDict, CIMultiDictProxy, MultiMapping - -from .hdrs import ( - CONTENT_DISPOSITION, - CONTENT_ENCODING, - CONTENT_LENGTH, - CONTENT_TRANSFER_ENCODING, - CONTENT_TYPE, -) -from .helpers import CHAR, TOKEN, parse_mimetype, reify -from .http import HeadersParser -from .payload import ( - JsonPayload, - LookupError, - Order, - Payload, - StringPayload, - get_payload, - payload_type, -) -from .streams import StreamReader - -__all__ = ( - "MultipartReader", - "MultipartWriter", - "BodyPartReader", - "BadContentDispositionHeader", - "BadContentDispositionParam", - "parse_content_disposition", - "content_disposition_filename", -) - - -if TYPE_CHECKING: # pragma: no cover - from .client_reqrep import ClientResponse - - -class BadContentDispositionHeader(RuntimeWarning): - pass - - -class BadContentDispositionParam(RuntimeWarning): - pass - - -def parse_content_disposition( - header: Optional[str], -) -> Tuple[Optional[str], Dict[str, str]]: - def is_token(string: str) -> bool: - return bool(string) and TOKEN >= set(string) - - def is_quoted(string: str) -> bool: - return string[0] == string[-1] == '"' - - def is_rfc5987(string: str) -> bool: - return is_token(string) and string.count("'") == 2 - - def is_extended_param(string: str) -> bool: - return string.endswith("*") - - def is_continuous_param(string: str) -> bool: - pos = string.find("*") + 1 - if not pos: - return False - substring = string[pos:-1] if string.endswith("*") else string[pos:] - return substring.isdigit() - - def unescape(text: str, *, chars: str = "".join(map(re.escape, CHAR))) -> str: - return re.sub(f"\\\\([{chars}])", "\\1", text) - - if not header: - return None, {} - - disptype, *parts = header.split(";") - if not is_token(disptype): - warnings.warn(BadContentDispositionHeader(header)) - return None, {} - - params: Dict[str, str] = {} - while parts: - item = parts.pop(0) - - if "=" not in item: - warnings.warn(BadContentDispositionHeader(header)) - return None, {} - - key, value = item.split("=", 1) - key = key.lower().strip() - value = value.lstrip() - - if key in params: - warnings.warn(BadContentDispositionHeader(header)) - return None, {} - - if not is_token(key): - warnings.warn(BadContentDispositionParam(item)) - continue - - elif is_continuous_param(key): - if is_quoted(value): - value = unescape(value[1:-1]) - elif not is_token(value): - warnings.warn(BadContentDispositionParam(item)) - continue - - elif is_extended_param(key): - if is_rfc5987(value): - encoding, _, value = value.split("'", 2) - encoding = encoding or "utf-8" - else: - warnings.warn(BadContentDispositionParam(item)) - continue - - try: - value = unquote(value, encoding, "strict") - except UnicodeDecodeError: # pragma: nocover - warnings.warn(BadContentDispositionParam(item)) - continue - - else: - failed = True - if is_quoted(value): - failed = False - value = unescape(value[1:-1].lstrip("\\/")) - elif is_token(value): - failed = False - elif parts: - # maybe just ; in filename, in any case this is just - # one case fix, for proper fix we need to redesign parser - _value = f"{value};{parts[0]}" - if is_quoted(_value): - parts.pop(0) - value = unescape(_value[1:-1].lstrip("\\/")) - failed = False - - if failed: - warnings.warn(BadContentDispositionHeader(header)) - return None, {} - - params[key] = value - - return disptype.lower(), params - - -def content_disposition_filename( - params: Mapping[str, str], name: str = "filename" -) -> Optional[str]: - name_suf = "%s*" % name - if not params: - return None - elif name_suf in params: - return params[name_suf] - elif name in params: - return params[name] - else: - parts = [] - fnparams = sorted( - (key, value) for key, value in params.items() if key.startswith(name_suf) - ) - for num, (key, value) in enumerate(fnparams): - _, tail = key.split("*", 1) - if tail.endswith("*"): - tail = tail[:-1] - if tail == str(num): - parts.append(value) - else: - break - if not parts: - return None - value = "".join(parts) - if "'" in value: - encoding, _, value = value.split("'", 2) - encoding = encoding or "utf-8" - return unquote(value, encoding, "strict") - return value - - -class MultipartResponseWrapper: - """Wrapper around the MultipartReader. - - It takes care about - underlying connection and close it when it needs in. - """ - - def __init__( - self, - resp: "ClientResponse", - stream: "MultipartReader", - ) -> None: - self.resp = resp - self.stream = stream - - def __aiter__(self) -> "MultipartResponseWrapper": - return self - - async def __anext__( - self, - ) -> Union["MultipartReader", "BodyPartReader"]: - part = await self.next() - if part is None: - raise StopAsyncIteration - return part - - def at_eof(self) -> bool: - """Returns True when all response data had been read.""" - return self.resp.content.at_eof() - - async def next( - self, - ) -> Optional[Union["MultipartReader", "BodyPartReader"]]: - """Emits next multipart reader object.""" - item = await self.stream.next() - if self.stream.at_eof(): - await self.release() - return item - - async def release(self) -> None: - """Release the connection gracefully. - - All remaining content is read to the void. - """ - await self.resp.release() - - -class BodyPartReader: - """Multipart reader for single body part.""" - - chunk_size = 8192 - - def __init__( - self, boundary: bytes, headers: "CIMultiDictProxy[str]", content: StreamReader - ) -> None: - self.headers = headers - self._boundary = boundary - self._content = content - self._at_eof = False - length = self.headers.get(CONTENT_LENGTH, None) - self._length = int(length) if length is not None else None - self._read_bytes = 0 - # TODO: typeing.Deque is not supported by Python 3.5 - self._unread: Deque[bytes] = deque() - self._prev_chunk: Optional[bytes] = None - self._content_eof = 0 - self._cache: Dict[str, Any] = {} - - def __aiter__(self) -> AsyncIterator["BodyPartReader"]: - return self # type: ignore[return-value] - - async def __anext__(self) -> bytes: - part = await self.next() - if part is None: - raise StopAsyncIteration - return part - - async def next(self) -> Optional[bytes]: - item = await self.read() - if not item: - return None - return item - - async def read(self, *, decode: bool = False) -> bytes: - """Reads body part data. - - decode: Decodes data following by encoding - method from Content-Encoding header. If it missed - data remains untouched - """ - if self._at_eof: - return b"" - data = bytearray() - while not self._at_eof: - data.extend(await self.read_chunk(self.chunk_size)) - if decode: - return self.decode(data) - return data - - async def read_chunk(self, size: int = chunk_size) -> bytes: - """Reads body part content chunk of the specified size. - - size: chunk size - """ - if self._at_eof: - return b"" - if self._length: - chunk = await self._read_chunk_from_length(size) - else: - chunk = await self._read_chunk_from_stream(size) - - self._read_bytes += len(chunk) - if self._read_bytes == self._length: - self._at_eof = True - if self._at_eof: - clrf = await self._content.readline() - assert ( - b"\r\n" == clrf - ), "reader did not read all the data or it is malformed" - return chunk - - async def _read_chunk_from_length(self, size: int) -> bytes: - # Reads body part content chunk of the specified size. - # The body part must has Content-Length header with proper value. - assert self._length is not None, "Content-Length required for chunked read" - chunk_size = min(size, self._length - self._read_bytes) - chunk = await self._content.read(chunk_size) - return chunk - - async def _read_chunk_from_stream(self, size: int) -> bytes: - # Reads content chunk of body part with unknown length. - # The Content-Length header for body part is not necessary. - assert ( - size >= len(self._boundary) + 2 - ), "Chunk size must be greater or equal than boundary length + 2" - first_chunk = self._prev_chunk is None - if first_chunk: - self._prev_chunk = await self._content.read(size) - - chunk = await self._content.read(size) - self._content_eof += int(self._content.at_eof()) - assert self._content_eof < 3, "Reading after EOF" - assert self._prev_chunk is not None - window = self._prev_chunk + chunk - sub = b"\r\n" + self._boundary - if first_chunk: - idx = window.find(sub) - else: - idx = window.find(sub, max(0, len(self._prev_chunk) - len(sub))) - if idx >= 0: - # pushing boundary back to content - with warnings.catch_warnings(): - warnings.filterwarnings("ignore", category=DeprecationWarning) - self._content.unread_data(window[idx:]) - if size > idx: - self._prev_chunk = self._prev_chunk[:idx] - chunk = window[len(self._prev_chunk) : idx] - if not chunk: - self._at_eof = True - result = self._prev_chunk - self._prev_chunk = chunk - return result - - async def readline(self) -> bytes: - """Reads body part by line by line.""" - if self._at_eof: - return b"" - - if self._unread: - line = self._unread.popleft() - else: - line = await self._content.readline() - - if line.startswith(self._boundary): - # the very last boundary may not come with \r\n, - # so set single rules for everyone - sline = line.rstrip(b"\r\n") - boundary = self._boundary - last_boundary = self._boundary + b"--" - # ensure that we read exactly the boundary, not something alike - if sline == boundary or sline == last_boundary: - self._at_eof = True - self._unread.append(line) - return b"" - else: - next_line = await self._content.readline() - if next_line.startswith(self._boundary): - line = line[:-2] # strip CRLF but only once - self._unread.append(next_line) - - return line - - async def release(self) -> None: - """Like read(), but reads all the data to the void.""" - if self._at_eof: - return - while not self._at_eof: - await self.read_chunk(self.chunk_size) - - async def text(self, *, encoding: Optional[str] = None) -> str: - """Like read(), but assumes that body part contains text data.""" - data = await self.read(decode=True) - # see https://www.w3.org/TR/html5/forms.html#multipart/form-data-encoding-algorithm # NOQA - # and https://dvcs.w3.org/hg/xhr/raw-file/tip/Overview.html#dom-xmlhttprequest-send # NOQA - encoding = encoding or self.get_charset(default="utf-8") - return data.decode(encoding) - - async def json(self, *, encoding: Optional[str] = None) -> Optional[Dict[str, Any]]: - """Like read(), but assumes that body parts contains JSON data.""" - data = await self.read(decode=True) - if not data: - return None - encoding = encoding or self.get_charset(default="utf-8") - return cast(Dict[str, Any], json.loads(data.decode(encoding))) - - async def form(self, *, encoding: Optional[str] = None) -> List[Tuple[str, str]]: - """Like read(), but assumes that body parts contain form urlencoded data.""" - data = await self.read(decode=True) - if not data: - return [] - if encoding is not None: - real_encoding = encoding - else: - real_encoding = self.get_charset(default="utf-8") - return parse_qsl( - data.rstrip().decode(real_encoding), - keep_blank_values=True, - encoding=real_encoding, - ) - - def at_eof(self) -> bool: - """Returns True if the boundary was reached or False otherwise.""" - return self._at_eof - - def decode(self, data: bytes) -> bytes: - """Decodes data. - - Decoding is done according the specified Content-Encoding - or Content-Transfer-Encoding headers value. - """ - if CONTENT_TRANSFER_ENCODING in self.headers: - data = self._decode_content_transfer(data) - if CONTENT_ENCODING in self.headers: - return self._decode_content(data) - return data - - def _decode_content(self, data: bytes) -> bytes: - encoding = self.headers.get(CONTENT_ENCODING, "").lower() - - if encoding == "deflate": - return zlib.decompress(data, -zlib.MAX_WBITS) - elif encoding == "gzip": - return zlib.decompress(data, 16 + zlib.MAX_WBITS) - elif encoding == "identity": - return data - else: - raise RuntimeError(f"unknown content encoding: {encoding}") - - def _decode_content_transfer(self, data: bytes) -> bytes: - encoding = self.headers.get(CONTENT_TRANSFER_ENCODING, "").lower() - - if encoding == "base64": - return base64.b64decode(data) - elif encoding == "quoted-printable": - return binascii.a2b_qp(data) - elif encoding in ("binary", "8bit", "7bit"): - return data - else: - raise RuntimeError( - "unknown content transfer encoding: {}" "".format(encoding) - ) - - def get_charset(self, default: str) -> str: - """Returns charset parameter from Content-Type header or default.""" - ctype = self.headers.get(CONTENT_TYPE, "") - mimetype = parse_mimetype(ctype) - return mimetype.parameters.get("charset", default) - - @reify - def name(self) -> Optional[str]: - """Returns name specified in Content-Disposition header. - - If the header is missing or malformed, returns None. - """ - _, params = parse_content_disposition(self.headers.get(CONTENT_DISPOSITION)) - return content_disposition_filename(params, "name") - - @reify - def filename(self) -> Optional[str]: - """Returns filename specified in Content-Disposition header. - - Returns None if the header is missing or malformed. - """ - _, params = parse_content_disposition(self.headers.get(CONTENT_DISPOSITION)) - return content_disposition_filename(params, "filename") - - -@payload_type(BodyPartReader, order=Order.try_first) -class BodyPartReaderPayload(Payload): - def __init__(self, value: BodyPartReader, *args: Any, **kwargs: Any) -> None: - super().__init__(value, *args, **kwargs) - - params: Dict[str, str] = {} - if value.name is not None: - params["name"] = value.name - if value.filename is not None: - params["filename"] = value.filename - - if params: - self.set_content_disposition("attachment", True, **params) - - async def write(self, writer: Any) -> None: - field = self._value - chunk = await field.read_chunk(size=2**16) - while chunk: - await writer.write(field.decode(chunk)) - chunk = await field.read_chunk(size=2**16) - - -class MultipartReader: - """Multipart body reader.""" - - #: Response wrapper, used when multipart readers constructs from response. - response_wrapper_cls = MultipartResponseWrapper - #: Multipart reader class, used to handle multipart/* body parts. - #: None points to type(self) - multipart_reader_cls = None - #: Body part reader class for non multipart/* content types. - part_reader_cls = BodyPartReader - - def __init__(self, headers: Mapping[str, str], content: StreamReader) -> None: - self.headers = headers - self._boundary = ("--" + self._get_boundary()).encode() - self._content = content - self._last_part: Optional[Union["MultipartReader", BodyPartReader]] = None - self._at_eof = False - self._at_bof = True - self._unread: List[bytes] = [] - - def __aiter__( - self, - ) -> AsyncIterator["BodyPartReader"]: - return self # type: ignore[return-value] - - async def __anext__( - self, - ) -> Optional[Union["MultipartReader", BodyPartReader]]: - part = await self.next() - if part is None: - raise StopAsyncIteration - return part - - @classmethod - def from_response( - cls, - response: "ClientResponse", - ) -> MultipartResponseWrapper: - """Constructs reader instance from HTTP response. - - :param response: :class:`~aiohttp.client.ClientResponse` instance - """ - obj = cls.response_wrapper_cls( - response, cls(response.headers, response.content) - ) - return obj - - def at_eof(self) -> bool: - """Returns True if the final boundary was reached, false otherwise.""" - return self._at_eof - - async def next( - self, - ) -> Optional[Union["MultipartReader", BodyPartReader]]: - """Emits the next multipart body part.""" - # So, if we're at BOF, we need to skip till the boundary. - if self._at_eof: - return None - await self._maybe_release_last_part() - if self._at_bof: - await self._read_until_first_boundary() - self._at_bof = False - else: - await self._read_boundary() - if self._at_eof: # we just read the last boundary, nothing to do there - return None - self._last_part = await self.fetch_next_part() - return self._last_part - - async def release(self) -> None: - """Reads all the body parts to the void till the final boundary.""" - while not self._at_eof: - item = await self.next() - if item is None: - break - await item.release() - - async def fetch_next_part( - self, - ) -> Union["MultipartReader", BodyPartReader]: - """Returns the next body part reader.""" - headers = await self._read_headers() - return self._get_part_reader(headers) - - def _get_part_reader( - self, - headers: "CIMultiDictProxy[str]", - ) -> Union["MultipartReader", BodyPartReader]: - """Dispatches the response by the `Content-Type` header. - - Returns a suitable reader instance. - - :param dict headers: Response headers - """ - ctype = headers.get(CONTENT_TYPE, "") - mimetype = parse_mimetype(ctype) - - if mimetype.type == "multipart": - if self.multipart_reader_cls is None: - return type(self)(headers, self._content) - return self.multipart_reader_cls(headers, self._content) - else: - return self.part_reader_cls(self._boundary, headers, self._content) - - def _get_boundary(self) -> str: - mimetype = parse_mimetype(self.headers[CONTENT_TYPE]) - - assert mimetype.type == "multipart", "multipart/* content type expected" - - if "boundary" not in mimetype.parameters: - raise ValueError( - "boundary missed for Content-Type: %s" % self.headers[CONTENT_TYPE] - ) - - boundary = mimetype.parameters["boundary"] - if len(boundary) > 70: - raise ValueError("boundary %r is too long (70 chars max)" % boundary) - - return boundary - - async def _readline(self) -> bytes: - if self._unread: - return self._unread.pop() - return await self._content.readline() - - async def _read_until_first_boundary(self) -> None: - while True: - chunk = await self._readline() - if chunk == b"": - raise ValueError( - "Could not find starting boundary %r" % (self._boundary) - ) - chunk = chunk.rstrip() - if chunk == self._boundary: - return - elif chunk == self._boundary + b"--": - self._at_eof = True - return - - async def _read_boundary(self) -> None: - chunk = (await self._readline()).rstrip() - if chunk == self._boundary: - pass - elif chunk == self._boundary + b"--": - self._at_eof = True - epilogue = await self._readline() - next_line = await self._readline() - - # the epilogue is expected and then either the end of input or the - # parent multipart boundary, if the parent boundary is found then - # it should be marked as unread and handed to the parent for - # processing - if next_line[:2] == b"--": - self._unread.append(next_line) - # otherwise the request is likely missing an epilogue and both - # lines should be passed to the parent for processing - # (this handles the old behavior gracefully) - else: - self._unread.extend([next_line, epilogue]) - else: - raise ValueError(f"Invalid boundary {chunk!r}, expected {self._boundary!r}") - - async def _read_headers(self) -> "CIMultiDictProxy[str]": - lines = [b""] - while True: - chunk = await self._content.readline() - chunk = chunk.strip() - lines.append(chunk) - if not chunk: - break - parser = HeadersParser() - headers, raw_headers = parser.parse_headers(lines) - return headers - - async def _maybe_release_last_part(self) -> None: - """Ensures that the last read body part is read completely.""" - if self._last_part is not None: - if not self._last_part.at_eof(): - await self._last_part.release() - self._unread.extend(self._last_part._unread) - self._last_part = None - - -_Part = Tuple[Payload, str, str] - - -class MultipartWriter(Payload): - """Multipart body writer.""" - - def __init__(self, subtype: str = "mixed", boundary: Optional[str] = None) -> None: - boundary = boundary if boundary is not None else uuid.uuid4().hex - # The underlying Payload API demands a str (utf-8), not bytes, - # so we need to ensure we don't lose anything during conversion. - # As a result, require the boundary to be ASCII only. - # In both situations. - - try: - self._boundary = boundary.encode("ascii") - except UnicodeEncodeError: - raise ValueError("boundary should contain ASCII only chars") from None - ctype = f"multipart/{subtype}; boundary={self._boundary_value}" - - super().__init__(None, content_type=ctype) - - self._parts: List[_Part] = [] - - def __enter__(self) -> "MultipartWriter": - return self - - def __exit__( - self, - exc_type: Optional[Type[BaseException]], - exc_val: Optional[BaseException], - exc_tb: Optional[TracebackType], - ) -> None: - pass - - def __iter__(self) -> Iterator[_Part]: - return iter(self._parts) - - def __len__(self) -> int: - return len(self._parts) - - def __bool__(self) -> bool: - return True - - _valid_tchar_regex = re.compile(rb"\A[!#$%&'*+\-.^_`|~\w]+\Z") - _invalid_qdtext_char_regex = re.compile(rb"[\x00-\x08\x0A-\x1F\x7F]") - - @property - def _boundary_value(self) -> str: - """Wrap boundary parameter value in quotes, if necessary. - - Reads self.boundary and returns a unicode sting. - """ - # Refer to RFCs 7231, 7230, 5234. - # - # parameter = token "=" ( token / quoted-string ) - # token = 1*tchar - # quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE - # qdtext = HTAB / SP / %x21 / %x23-5B / %x5D-7E / obs-text - # obs-text = %x80-FF - # quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text ) - # tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" - # / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~" - # / DIGIT / ALPHA - # ; any VCHAR, except delimiters - # VCHAR = %x21-7E - value = self._boundary - if re.match(self._valid_tchar_regex, value): - return value.decode("ascii") # cannot fail - - if re.search(self._invalid_qdtext_char_regex, value): - raise ValueError("boundary value contains invalid characters") - - # escape %x5C and %x22 - quoted_value_content = value.replace(b"\\", b"\\\\") - quoted_value_content = quoted_value_content.replace(b'"', b'\\"') - - return '"' + quoted_value_content.decode("ascii") + '"' - - @property - def boundary(self) -> str: - return self._boundary.decode("ascii") - - def append(self, obj: Any, headers: Optional[MultiMapping[str]] = None) -> Payload: - if headers is None: - headers = CIMultiDict() - - if isinstance(obj, Payload): - obj.headers.update(headers) - return self.append_payload(obj) - else: - try: - payload = get_payload(obj, headers=headers) - except LookupError: - raise TypeError("Cannot create payload from %r" % obj) - else: - return self.append_payload(payload) - - def append_payload(self, payload: Payload) -> Payload: - """Adds a new body part to multipart writer.""" - # compression - encoding: Optional[str] = payload.headers.get( - CONTENT_ENCODING, - "", - ).lower() - if encoding and encoding not in ("deflate", "gzip", "identity"): - raise RuntimeError(f"unknown content encoding: {encoding}") - if encoding == "identity": - encoding = None - - # te encoding - te_encoding: Optional[str] = payload.headers.get( - CONTENT_TRANSFER_ENCODING, - "", - ).lower() - if te_encoding not in ("", "base64", "quoted-printable", "binary"): - raise RuntimeError( - "unknown content transfer encoding: {}" "".format(te_encoding) - ) - if te_encoding == "binary": - te_encoding = None - - # size - size = payload.size - if size is not None and not (encoding or te_encoding): - payload.headers[CONTENT_LENGTH] = str(size) - - self._parts.append((payload, encoding, te_encoding)) # type: ignore[arg-type] - return payload - - def append_json( - self, obj: Any, headers: Optional[MultiMapping[str]] = None - ) -> Payload: - """Helper to append JSON part.""" - if headers is None: - headers = CIMultiDict() - - return self.append_payload(JsonPayload(obj, headers=headers)) - - def append_form( - self, - obj: Union[Sequence[Tuple[str, str]], Mapping[str, str]], - headers: Optional[MultiMapping[str]] = None, - ) -> Payload: - """Helper to append form urlencoded part.""" - assert isinstance(obj, (Sequence, Mapping)) - - if headers is None: - headers = CIMultiDict() - - if isinstance(obj, Mapping): - obj = list(obj.items()) - data = urlencode(obj, doseq=True) - - return self.append_payload( - StringPayload( - data, headers=headers, content_type="application/x-www-form-urlencoded" - ) - ) - - @property - def size(self) -> Optional[int]: - """Size of the payload.""" - total = 0 - for part, encoding, te_encoding in self._parts: - if encoding or te_encoding or part.size is None: - return None - - total += int( - 2 - + len(self._boundary) - + 2 - + part.size # b'--'+self._boundary+b'\r\n' - + len(part._binary_headers) - + 2 # b'\r\n' - ) - - total += 2 + len(self._boundary) + 4 # b'--'+self._boundary+b'--\r\n' - return total - - async def write(self, writer: Any, close_boundary: bool = True) -> None: - """Write body.""" - for part, encoding, te_encoding in self._parts: - await writer.write(b"--" + self._boundary + b"\r\n") - await writer.write(part._binary_headers) - - if encoding or te_encoding: - w = MultipartPayloadWriter(writer) - if encoding: - w.enable_compression(encoding) - if te_encoding: - w.enable_encoding(te_encoding) - await part.write(w) # type: ignore[arg-type] - await w.write_eof() - else: - await part.write(writer) - - await writer.write(b"\r\n") - - if close_boundary: - await writer.write(b"--" + self._boundary + b"--\r\n") - - -class MultipartPayloadWriter: - def __init__(self, writer: Any) -> None: - self._writer = writer - self._encoding: Optional[str] = None - self._compress: Any = None - self._encoding_buffer: Optional[bytearray] = None - - def enable_encoding(self, encoding: str) -> None: - if encoding == "base64": - self._encoding = encoding - self._encoding_buffer = bytearray() - elif encoding == "quoted-printable": - self._encoding = "quoted-printable" - - def enable_compression( - self, encoding: str = "deflate", strategy: int = zlib.Z_DEFAULT_STRATEGY - ) -> None: - zlib_mode = 16 + zlib.MAX_WBITS if encoding == "gzip" else -zlib.MAX_WBITS - self._compress = zlib.compressobj(wbits=zlib_mode, strategy=strategy) - - async def write_eof(self) -> None: - if self._compress is not None: - chunk = self._compress.flush() - if chunk: - self._compress = None - await self.write(chunk) - - if self._encoding == "base64": - if self._encoding_buffer: - await self._writer.write(base64.b64encode(self._encoding_buffer)) - - async def write(self, chunk: bytes) -> None: - if self._compress is not None: - if chunk: - chunk = self._compress.compress(chunk) - if not chunk: - return - - if self._encoding == "base64": - buf = self._encoding_buffer - assert buf is not None - buf.extend(chunk) - - if buf: - div, mod = divmod(len(buf), 3) - enc_chunk, self._encoding_buffer = (buf[: div * 3], buf[div * 3 :]) - if enc_chunk: - b64chunk = base64.b64encode(enc_chunk) - await self._writer.write(b64chunk) - elif self._encoding == "quoted-printable": - await self._writer.write(binascii.b2a_qp(chunk)) - else: - await self._writer.write(chunk) diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio/components/number.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio/components/number.py deleted file mode 100644 index 5d2b9fcccc1469d0fee4c79c77011d4d8a67bcb0..0000000000000000000000000000000000000000 --- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio/components/number.py +++ /dev/null @@ -1,244 +0,0 @@ -"""gr.Number() component.""" - -from __future__ import annotations - -import math -from typing import Callable, Literal - -import numpy as np -from gradio_client.documentation import document, set_documentation_group -from gradio_client.serializing import NumberSerializable - -from gradio.components.base import FormComponent, IOComponent, _Keywords -from gradio.events import ( - Changeable, - Focusable, - Inputable, - Submittable, -) -from gradio.exceptions import Error -from gradio.interpretation import NeighborInterpretable - -set_documentation_group("component") - - -@document() -class Number( - FormComponent, - Changeable, - Inputable, - Submittable, - Focusable, - IOComponent, - NumberSerializable, - NeighborInterpretable, -): - """ - Creates a numeric field for user to enter numbers as input or display numeric output. - Preprocessing: passes field value as a {float} or {int} into the function, depending on `precision`. - Postprocessing: expects an {int} or {float} returned from the function and sets field value to it. - Examples-format: a {float} or {int} representing the number's value. - - Demos: tax_calculator, titanic_survival, blocks_simple_squares - """ - - def __init__( - self, - value: float | Callable | None = None, - *, - label: str | None = None, - info: str | None = None, - every: float | None = None, - show_label: bool | None = None, - container: bool = True, - scale: int | None = None, - min_width: int = 160, - interactive: bool | None = None, - visible: bool = True, - elem_id: str | None = None, - elem_classes: list[str] | str | None = None, - precision: int | None = None, - minimum: float | None = None, - maximum: float | None = None, - step: float = 1, - **kwargs, - ): - """ - Parameters: - value: default value. If callable, the function will be called whenever the app loads to set the initial value of the component. - label: component name in interface. - info: additional component description. - every: If `value` is a callable, run the function 'every' number of seconds while the client connection is open. Has no effect otherwise. Queue must be enabled. The event can be accessed (e.g. to cancel it) via this component's .load_event attribute. - show_label: if True, will display label. - container: If True, will place the component in a container - providing some extra padding around the border. - scale: relative width compared to adjacent Components in a Row. For example, if Component A has scale=2, and Component B has scale=1, A will be twice as wide as B. Should be an integer. - min_width: minimum pixel width, will wrap if not sufficient screen space to satisfy this value. If a certain scale value results in this Component being narrower than min_width, the min_width parameter will be respected first. - interactive: if True, will be editable; if False, editing will be disabled. If not provided, this is inferred based on whether the component is used as an input or output. - visible: If False, component will be hidden. - elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles. - elem_classes: An optional list of strings that are assigned as the classes of this component in the HTML DOM. Can be used for targeting CSS styles. - precision: Precision to round input/output to. If set to 0, will round to nearest integer and convert type to int. If None, no rounding happens. - minimum: Minimum value. Only applied when component is used as an input. If a user provides a smaller value, a gr.Error exception is raised by the backend. - maximum: Maximum value. Only applied when component is used as an input. If a user provides a larger value, a gr.Error exception is raised by the backend. - step: The interval between allowed numbers in the component. Can be used along with optional parameters `minimum` and `maximum` to create a range of legal values starting from `minimum` and incrementing according to this parameter. - """ - self.precision = precision - self.minimum = minimum - self.maximum = maximum - self.step = step - - IOComponent.__init__( - self, - label=label, - info=info, - every=every, - show_label=show_label, - container=container, - scale=scale, - min_width=min_width, - interactive=interactive, - visible=visible, - elem_id=elem_id, - elem_classes=elem_classes, - value=value, - **kwargs, - ) - NeighborInterpretable.__init__(self) - - @staticmethod - def _round_to_precision(num: float | int, precision: int | None) -> float | int: - """ - Round to a given precision. - - If precision is None, no rounding happens. If 0, num is converted to int. - - Parameters: - num: Number to round. - precision: Precision to round to. - Returns: - rounded number - """ - if precision is None: - return float(num) - elif precision == 0: - return int(round(num, precision)) - else: - return round(num, precision) - - def get_config(self): - return { - "value": self.value, - "minimum": self.minimum, - "maximum": self.maximum, - "step": self.step, - "container": self.container, - **IOComponent.get_config(self), - } - - @staticmethod - def update( - value: float | Literal[_Keywords.NO_VALUE] | None = _Keywords.NO_VALUE, - minimum: float | None = None, - maximum: float | None = None, - step: float = 1, - label: str | None = None, - info: str | None = None, - show_label: bool | None = None, - container: bool | None = None, - scale: int | None = None, - min_width: int | None = None, - interactive: bool | None = None, - visible: bool | None = None, - ): - return { - "label": label, - "info": info, - "show_label": show_label, - "container": container, - "scale": scale, - "min_width": min_width, - "visible": visible, - "value": value, - "minimum": minimum, - "maximum": maximum, - "step": step, - "interactive": interactive, - "__type__": "update", - } - - def preprocess(self, x: float | None) -> float | None: - """ - Parameters: - x: numeric input - Returns: - number representing function input - """ - if x is None: - return None - elif self.minimum is not None and x < self.minimum: - raise Error(f"Value {x} is less than minimum value {self.minimum}.") - elif self.maximum is not None and x > self.maximum: - raise Error(f"Value {x} is greater than maximum value {self.maximum}.") - return self._round_to_precision(x, self.precision) - - def postprocess(self, y: float | None) -> float | None: - """ - Any postprocessing needed to be performed on function output. - - Parameters: - y: numeric output - Returns: - number representing function output - """ - if y is None: - return None - return self._round_to_precision(y, self.precision) - - def set_interpret_parameters( - self, steps: int = 3, delta: float = 1, delta_type: str = "percent" - ): - """ - Calculates interpretation scores of numeric values close to the input number. - Parameters: - steps: Number of nearby values to measure in each direction (above and below the input number). - delta: Size of step in each direction between nearby values. - delta_type: "percent" if delta step between nearby values should be a calculated as a percent, or "absolute" if delta should be a constant step change. - """ - self.interpretation_steps = steps - self.interpretation_delta = delta - self.interpretation_delta_type = delta_type - return self - - def get_interpretation_neighbors(self, x: float | int) -> tuple[list[float], dict]: - x = self._round_to_precision(x, self.precision) - if self.interpretation_delta_type == "percent": - delta = 1.0 * self.interpretation_delta * x / 100 - elif self.interpretation_delta_type == "absolute": - delta = self.interpretation_delta - else: - delta = self.interpretation_delta - if self.precision == 0 and math.floor(delta) != delta: - raise ValueError( - f"Delta value {delta} is not an integer and precision=0. Cannot generate valid set of neighbors. " - "If delta_type='percent', pick a value of delta such that x * delta is an integer. " - "If delta_type='absolute', pick a value of delta that is an integer." - ) - # run_interpretation will preprocess the neighbors so no need to convert to int here - negatives = ( - np.array(x) + np.arange(-self.interpretation_steps, 0) * delta - ).tolist() - positives = ( - np.array(x) + np.arange(1, self.interpretation_steps + 1) * delta - ).tolist() - return negatives + positives, {} - - def get_interpretation_scores( - self, x: float, neighbors: list[float], scores: list[float | None], **kwargs - ) -> list[tuple[float, float | None]]: - """ - Returns: - Each tuple set represents a numeric value near the input and its corresponding interpretation score. - """ - interpretation = list(zip(neighbors, scores)) - interpretation.insert(int(len(interpretation) / 2), (x, None)) - return interpretation diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio/components/radio.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio/components/radio.py deleted file mode 100644 index 3e8f79ab9ff1259876ca2ad1fe3f3e078b92681c..0000000000000000000000000000000000000000 --- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio/components/radio.py +++ /dev/null @@ -1,197 +0,0 @@ -"""gr.Radio() component.""" - -from __future__ import annotations - -from typing import Any, Callable, Literal - -from gradio_client.documentation import document, set_documentation_group -from gradio_client.serializing import StringSerializable - -from gradio.components.base import FormComponent, IOComponent, _Keywords -from gradio.deprecation import warn_deprecation, warn_style_method_deprecation -from gradio.events import Changeable, EventListenerMethod, Inputable, Selectable -from gradio.interpretation import NeighborInterpretable - -set_documentation_group("component") - - -@document() -class Radio( - FormComponent, - Selectable, - Changeable, - Inputable, - IOComponent, - StringSerializable, - NeighborInterpretable, -): - """ - Creates a set of (string or numeric type) radio buttons of which only one can be selected. - Preprocessing: passes the value of the selected radio button as a {str} or {int} or {float} or its index as an {int} into the function, depending on `type`. - Postprocessing: expects a {str} or {int} or {float} corresponding to the value of the radio button to be selected. - Examples-format: a {str} representing the radio option to select. - - Demos: sentence_builder, titanic_survival, blocks_essay - """ - - def __init__( - self, - choices: list[str | int | float] | None = None, - *, - value: str | int | float | Callable | None = None, - type: str = "value", - label: str | None = None, - info: str | None = None, - every: float | None = None, - show_label: bool | None = None, - container: bool = True, - scale: int | None = None, - min_width: int = 160, - interactive: bool | None = None, - visible: bool = True, - elem_id: str | None = None, - elem_classes: list[str] | str | None = None, - **kwargs, - ): - """ - Parameters: - choices: list of options to select from. - value: the button selected by default. If None, no button is selected by default. If callable, the function will be called whenever the app loads to set the initial value of the component. - type: Type of value to be returned by component. "value" returns the string of the choice selected, "index" returns the index of the choice selected. - label: component name in interface. - info: additional component description. - every: If `value` is a callable, run the function 'every' number of seconds while the client connection is open. Has no effect otherwise. Queue must be enabled. The event can be accessed (e.g. to cancel it) via this component's .load_event attribute. - show_label: if True, will display label. - container: If True, will place the component in a container - providing some extra padding around the border. - scale: relative width compared to adjacent Components in a Row. For example, if Component A has scale=2, and Component B has scale=1, A will be twice as wide as B. Should be an integer. - min_width: minimum pixel width, will wrap if not sufficient screen space to satisfy this value. If a certain scale value results in this Component being narrower than min_width, the min_width parameter will be respected first. - interactive: if True, choices in this radio group will be selectable; if False, selection will be disabled. If not provided, this is inferred based on whether the component is used as an input or output. - visible: If False, component will be hidden. - elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles. - elem_classes: An optional list of strings that are assigned as the classes of this component in the HTML DOM. Can be used for targeting CSS styles. - """ - self.choices = choices or [] - valid_types = ["value", "index"] - if type not in valid_types: - raise ValueError( - f"Invalid value for parameter `type`: {type}. Please choose from one of: {valid_types}" - ) - self.type = type - self.select: EventListenerMethod - """ - Event listener for when the user selects Radio option. - Uses event data gradio.SelectData to carry `value` referring to label of selected option, and `index` to refer to index. - See EventData documentation on how to use this event data. - """ - IOComponent.__init__( - self, - label=label, - info=info, - every=every, - show_label=show_label, - container=container, - scale=scale, - min_width=min_width, - interactive=interactive, - visible=visible, - elem_id=elem_id, - elem_classes=elem_classes, - value=value, - **kwargs, - ) - NeighborInterpretable.__init__(self) - - def get_config(self): - return { - "choices": self.choices, - "value": self.value, - **IOComponent.get_config(self), - } - - def example_inputs(self) -> dict[str, Any]: - return { - "raw": self.choices[0] if self.choices else None, - "serialized": self.choices[0] if self.choices else None, - } - - @staticmethod - def update( - value: str - | int - | float - | Literal[_Keywords.NO_VALUE] - | None = _Keywords.NO_VALUE, - choices: list[str | int | float] | None = None, - label: str | None = None, - info: str | None = None, - show_label: bool | None = None, - container: bool | None = None, - scale: int | None = None, - min_width: int | None = None, - interactive: bool | None = None, - visible: bool | None = None, - ): - return { - "choices": choices, - "label": label, - "info": info, - "show_label": show_label, - "container": container, - "scale": scale, - "min_width": min_width, - "interactive": interactive, - "visible": visible, - "value": value, - "__type__": "update", - } - - def preprocess(self, x: str | int | float | None) -> str | int | float | None: - """ - Parameters: - x: selected choice - Returns: - selected choice as string or index within choice list - """ - if self.type == "value": - return x - elif self.type == "index": - if x is None: - return None - else: - return self.choices.index(x) - else: - raise ValueError( - f"Unknown type: {self.type}. Please choose from: 'value', 'index'." - ) - - def get_interpretation_neighbors(self, x): - choices = list(self.choices) - choices.remove(x) - return choices, {} - - def get_interpretation_scores( - self, x, neighbors, scores: list[float | None], **kwargs - ) -> list: - """ - Returns: - Each value represents the interpretation score corresponding to each choice. - """ - scores.insert(self.choices.index(x), None) - return scores - - def style( - self, - *, - item_container: bool | None = None, - container: bool | None = None, - **kwargs, - ): - """ - This method is deprecated. Please set these arguments in the constructor instead. - """ - warn_style_method_deprecation() - if item_container is not None: - warn_deprecation("The `item_container` parameter is deprecated.") - if container is not None: - self.container = container - return self diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/matplotlib/_mathtext.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/matplotlib/_mathtext.py deleted file mode 100644 index 3a934c21fd50764515fe4c56810489c50510079b..0000000000000000000000000000000000000000 --- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/matplotlib/_mathtext.py +++ /dev/null @@ -1,2597 +0,0 @@ -""" -Implementation details for :mod:`.mathtext`. -""" - -import copy -from collections import namedtuple -import enum -import functools -import logging -import os -import re -import types -import unicodedata - -import numpy as np -from pyparsing import ( - Empty, Forward, Literal, NotAny, oneOf, OneOrMore, Optional, - ParseBaseException, ParseException, ParseExpression, ParseFatalException, - ParserElement, ParseResults, QuotedString, Regex, StringEnd, ZeroOrMore, - pyparsing_common) - -import matplotlib as mpl -from . import _api, cbook -from ._mathtext_data import ( - latex_to_bakoma, stix_glyph_fixes, stix_virtual_fonts, tex2uni) -from .font_manager import FontProperties, findfont, get_font -from .ft2font import FT2Image, KERNING_DEFAULT - - -ParserElement.enablePackrat() -_log = logging.getLogger("matplotlib.mathtext") - - -############################################################################## -# FONTS - - -@_api.delete_parameter("3.6", "math") -def get_unicode_index(symbol, math=False): # Publicly exported. - r""" - Return the integer index (from the Unicode table) of *symbol*. - - Parameters - ---------- - symbol : str - A single (Unicode) character, a TeX command (e.g. r'\pi') or a Type1 - symbol name (e.g. 'phi'). - math : bool, default: False - If True (deprecated), replace ASCII hyphen-minus by Unicode minus. - """ - # From UTF #25: U+2212 minus sign is the preferred - # representation of the unary and binary minus sign rather than - # the ASCII-derived U+002D hyphen-minus, because minus sign is - # unambiguous and because it is rendered with a more desirable - # length, usually longer than a hyphen. - # Remove this block when the 'math' parameter is deleted. - if math and symbol == '-': - return 0x2212 - try: # This will succeed if symbol is a single Unicode char - return ord(symbol) - except TypeError: - pass - try: # Is symbol a TeX symbol (i.e. \alpha) - return tex2uni[symbol.strip("\\")] - except KeyError as err: - raise ValueError( - "'{}' is not a valid Unicode character or TeX/Type1 symbol" - .format(symbol)) from err - - -VectorParse = namedtuple("VectorParse", "width height depth glyphs rects", - module="matplotlib.mathtext") -VectorParse.__doc__ = r""" -The namedtuple type returned by ``MathTextParser("path").parse(...)``. - -This tuple contains the global metrics (*width*, *height*, *depth*), a list of -*glyphs* (including their positions) and of *rect*\angles. -""" - - -RasterParse = namedtuple("RasterParse", "ox oy width height depth image", - module="matplotlib.mathtext") -RasterParse.__doc__ = r""" -The namedtuple type returned by ``MathTextParser("agg").parse(...)``. - -This tuple contains the global metrics (*width*, *height*, *depth*), and a -raster *image*. The offsets *ox*, *oy* are always zero. -""" - - -class Output: - r""" - Result of `ship`\ping a box: lists of positioned glyphs and rectangles. - - This class is not exposed to end users, but converted to a `VectorParse` or - a `RasterParse` by `.MathTextParser.parse`. - """ - - def __init__(self, box): - self.box = box - self.glyphs = [] # (ox, oy, info) - self.rects = [] # (x1, y1, x2, y2) - - def to_vector(self): - w, h, d = map( - np.ceil, [self.box.width, self.box.height, self.box.depth]) - gs = [(info.font, info.fontsize, info.num, ox, h - oy + info.offset) - for ox, oy, info in self.glyphs] - rs = [(x1, h - y2, x2 - x1, y2 - y1) - for x1, y1, x2, y2 in self.rects] - return VectorParse(w, h + d, d, gs, rs) - - def to_raster(self): - # Metrics y's and mathtext y's are oriented in opposite directions, - # hence the switch between ymin and ymax. - xmin = min([*[ox + info.metrics.xmin for ox, oy, info in self.glyphs], - *[x1 for x1, y1, x2, y2 in self.rects], 0]) - 1 - ymin = min([*[oy - info.metrics.ymax for ox, oy, info in self.glyphs], - *[y1 for x1, y1, x2, y2 in self.rects], 0]) - 1 - xmax = max([*[ox + info.metrics.xmax for ox, oy, info in self.glyphs], - *[x2 for x1, y1, x2, y2 in self.rects], 0]) + 1 - ymax = max([*[oy - info.metrics.ymin for ox, oy, info in self.glyphs], - *[y2 for x1, y1, x2, y2 in self.rects], 0]) + 1 - w = xmax - xmin - h = ymax - ymin - self.box.depth - d = ymax - ymin - self.box.height - image = FT2Image(np.ceil(w), np.ceil(h + max(d, 0))) - - # Ideally, we could just use self.glyphs and self.rects here, shifting - # their coordinates by (-xmin, -ymin), but this yields slightly - # different results due to floating point slop; shipping twice is the - # old approach and keeps baseline images backcompat. - shifted = ship(self.box, (-xmin, -ymin)) - - for ox, oy, info in shifted.glyphs: - info.font.draw_glyph_to_bitmap( - image, ox, oy - info.metrics.iceberg, info.glyph, - antialiased=mpl.rcParams['text.antialiased']) - for x1, y1, x2, y2 in shifted.rects: - height = max(int(y2 - y1) - 1, 0) - if height == 0: - center = (y2 + y1) / 2 - y = int(center - (height + 1) / 2) - else: - y = int(y1) - image.draw_rect_filled(int(x1), y, np.ceil(x2), y + height) - return RasterParse(0, 0, w, h + d, d, image) - - -class Fonts: - """ - An abstract base class for a system of fonts to use for mathtext. - - The class must be able to take symbol keys and font file names and - return the character metrics. It also delegates to a backend class - to do the actual drawing. - """ - - def __init__(self, default_font_prop, load_glyph_flags): - """ - Parameters - ---------- - default_font_prop : `~.font_manager.FontProperties` - The default non-math font, or the base font for Unicode (generic) - font rendering. - load_glyph_flags : int - Flags passed to the glyph loader (e.g. ``FT_Load_Glyph`` and - ``FT_Load_Char`` for FreeType-based fonts). - """ - self.default_font_prop = default_font_prop - self.load_glyph_flags = load_glyph_flags - - def get_kern(self, font1, fontclass1, sym1, fontsize1, - font2, fontclass2, sym2, fontsize2, dpi): - """ - Get the kerning distance for font between *sym1* and *sym2*. - - See `~.Fonts.get_metrics` for a detailed description of the parameters. - """ - return 0. - - def get_metrics(self, font, font_class, sym, fontsize, dpi): - r""" - Parameters - ---------- - font : str - One of the TeX font names: "tt", "it", "rm", "cal", "sf", "bf", - "default", "regular", "bb", "frak", "scr". "default" and "regular" - are synonyms and use the non-math font. - font_class : str - One of the TeX font names (as for *font*), but **not** "bb", - "frak", or "scr". This is used to combine two font classes. The - only supported combination currently is ``get_metrics("frak", "bf", - ...)``. - sym : str - A symbol in raw TeX form, e.g., "1", "x", or "\sigma". - fontsize : float - Font size in points. - dpi : float - Rendering dots-per-inch. - - Returns - ------- - object - - The returned object has the following attributes (all floats, - except *slanted*): - - - *advance*: The advance distance (in points) of the glyph. - - *height*: The height of the glyph in points. - - *width*: The width of the glyph in points. - - *xmin*, *xmax*, *ymin*, *ymax*: The ink rectangle of the glyph - - *iceberg*: The distance from the baseline to the top of the - glyph. (This corresponds to TeX's definition of "height".) - - *slanted*: Whether the glyph should be considered as "slanted" - (currently used for kerning sub/superscripts). - """ - info = self._get_info(font, font_class, sym, fontsize, dpi) - return info.metrics - - def render_glyph( - self, output, ox, oy, font, font_class, sym, fontsize, dpi): - """ - At position (*ox*, *oy*), draw the glyph specified by the remaining - parameters (see `get_metrics` for their detailed description). - """ - info = self._get_info(font, font_class, sym, fontsize, dpi) - output.glyphs.append((ox, oy, info)) - - def render_rect_filled(self, output, x1, y1, x2, y2): - """ - Draw a filled rectangle from (*x1*, *y1*) to (*x2*, *y2*). - """ - output.rects.append((x1, y1, x2, y2)) - - def get_xheight(self, font, fontsize, dpi): - """ - Get the xheight for the given *font* and *fontsize*. - """ - raise NotImplementedError() - - def get_underline_thickness(self, font, fontsize, dpi): - """ - Get the line thickness that matches the given font. Used as a - base unit for drawing lines such as in a fraction or radical. - """ - raise NotImplementedError() - - def get_used_characters(self): - """ - Get the set of characters that were used in the math - expression. Used by backends that need to subset fonts so - they know which glyphs to include. - """ - return self.used_characters - - def get_sized_alternatives_for_symbol(self, fontname, sym): - """ - Override if your font provides multiple sizes of the same - symbol. Should return a list of symbols matching *sym* in - various sizes. The expression renderer will select the most - appropriate size for a given situation from this list. - """ - return [(fontname, sym)] - - -class TruetypeFonts(Fonts): - """ - A generic base class for all font setups that use Truetype fonts - (through FT2Font). - """ - - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - # Per-instance cache. - self._get_info = functools.lru_cache(None)(self._get_info) - self._fonts = {} - - filename = findfont(self.default_font_prop) - default_font = get_font(filename) - self._fonts['default'] = default_font - self._fonts['regular'] = default_font - - def _get_font(self, font): - if font in self.fontmap: - basename = self.fontmap[font] - else: - basename = font - cached_font = self._fonts.get(basename) - if cached_font is None and os.path.exists(basename): - cached_font = get_font(basename) - self._fonts[basename] = cached_font - self._fonts[cached_font.postscript_name] = cached_font - self._fonts[cached_font.postscript_name.lower()] = cached_font - return cached_font - - def _get_offset(self, font, glyph, fontsize, dpi): - if font.postscript_name == 'Cmex10': - return (glyph.height / 64 / 2) + (fontsize/3 * dpi/72) - return 0. - - # The return value of _get_info is cached per-instance. - def _get_info(self, fontname, font_class, sym, fontsize, dpi): - font, num, slanted = self._get_glyph(fontname, font_class, sym) - font.set_size(fontsize, dpi) - glyph = font.load_char(num, flags=self.load_glyph_flags) - - xmin, ymin, xmax, ymax = [val/64.0 for val in glyph.bbox] - offset = self._get_offset(font, glyph, fontsize, dpi) - metrics = types.SimpleNamespace( - advance = glyph.linearHoriAdvance/65536.0, - height = glyph.height/64.0, - width = glyph.width/64.0, - xmin = xmin, - xmax = xmax, - ymin = ymin+offset, - ymax = ymax+offset, - # iceberg is the equivalent of TeX's "height" - iceberg = glyph.horiBearingY/64.0 + offset, - slanted = slanted - ) - - return types.SimpleNamespace( - font = font, - fontsize = fontsize, - postscript_name = font.postscript_name, - metrics = metrics, - num = num, - glyph = glyph, - offset = offset - ) - - def get_xheight(self, fontname, fontsize, dpi): - font = self._get_font(fontname) - font.set_size(fontsize, dpi) - pclt = font.get_sfnt_table('pclt') - if pclt is None: - # Some fonts don't store the xHeight, so we do a poor man's xHeight - metrics = self.get_metrics( - fontname, mpl.rcParams['mathtext.default'], 'x', fontsize, dpi) - return metrics.iceberg - xHeight = (pclt['xHeight'] / 64.0) * (fontsize / 12.0) * (dpi / 100.0) - return xHeight - - def get_underline_thickness(self, font, fontsize, dpi): - # This function used to grab underline thickness from the font - # metrics, but that information is just too un-reliable, so it - # is now hardcoded. - return ((0.75 / 12.0) * fontsize * dpi) / 72.0 - - def get_kern(self, font1, fontclass1, sym1, fontsize1, - font2, fontclass2, sym2, fontsize2, dpi): - if font1 == font2 and fontsize1 == fontsize2: - info1 = self._get_info(font1, fontclass1, sym1, fontsize1, dpi) - info2 = self._get_info(font2, fontclass2, sym2, fontsize2, dpi) - font = info1.font - return font.get_kerning(info1.num, info2.num, KERNING_DEFAULT) / 64 - return super().get_kern(font1, fontclass1, sym1, fontsize1, - font2, fontclass2, sym2, fontsize2, dpi) - - -class BakomaFonts(TruetypeFonts): - """ - Use the Bakoma TrueType fonts for rendering. - - Symbols are strewn about a number of font files, each of which has - its own proprietary 8-bit encoding. - """ - _fontmap = { - 'cal': 'cmsy10', - 'rm': 'cmr10', - 'tt': 'cmtt10', - 'it': 'cmmi10', - 'bf': 'cmb10', - 'sf': 'cmss10', - 'ex': 'cmex10', - } - - def __init__(self, *args, **kwargs): - self._stix_fallback = StixFonts(*args, **kwargs) - - super().__init__(*args, **kwargs) - self.fontmap = {} - for key, val in self._fontmap.items(): - fullpath = findfont(val) - self.fontmap[key] = fullpath - self.fontmap[val] = fullpath - - _slanted_symbols = set(r"\int \oint".split()) - - def _get_glyph(self, fontname, font_class, sym): - font = None - if fontname in self.fontmap and sym in latex_to_bakoma: - basename, num = latex_to_bakoma[sym] - slanted = (basename == "cmmi10") or sym in self._slanted_symbols - font = self._get_font(basename) - elif len(sym) == 1: - slanted = (fontname == "it") - font = self._get_font(fontname) - if font is not None: - num = ord(sym) - if font is not None and font.get_char_index(num) != 0: - return font, num, slanted - else: - return self._stix_fallback._get_glyph(fontname, font_class, sym) - - # The Bakoma fonts contain many pre-sized alternatives for the - # delimiters. The AutoSizedChar class will use these alternatives - # and select the best (closest sized) glyph. - _size_alternatives = { - '(': [('rm', '('), ('ex', '\xa1'), ('ex', '\xb3'), - ('ex', '\xb5'), ('ex', '\xc3')], - ')': [('rm', ')'), ('ex', '\xa2'), ('ex', '\xb4'), - ('ex', '\xb6'), ('ex', '\x21')], - '{': [('cal', '{'), ('ex', '\xa9'), ('ex', '\x6e'), - ('ex', '\xbd'), ('ex', '\x28')], - '}': [('cal', '}'), ('ex', '\xaa'), ('ex', '\x6f'), - ('ex', '\xbe'), ('ex', '\x29')], - # The fourth size of '[' is mysteriously missing from the BaKoMa - # font, so I've omitted it for both '[' and ']' - '[': [('rm', '['), ('ex', '\xa3'), ('ex', '\x68'), - ('ex', '\x22')], - ']': [('rm', ']'), ('ex', '\xa4'), ('ex', '\x69'), - ('ex', '\x23')], - r'\lfloor': [('ex', '\xa5'), ('ex', '\x6a'), - ('ex', '\xb9'), ('ex', '\x24')], - r'\rfloor': [('ex', '\xa6'), ('ex', '\x6b'), - ('ex', '\xba'), ('ex', '\x25')], - r'\lceil': [('ex', '\xa7'), ('ex', '\x6c'), - ('ex', '\xbb'), ('ex', '\x26')], - r'\rceil': [('ex', '\xa8'), ('ex', '\x6d'), - ('ex', '\xbc'), ('ex', '\x27')], - r'\langle': [('ex', '\xad'), ('ex', '\x44'), - ('ex', '\xbf'), ('ex', '\x2a')], - r'\rangle': [('ex', '\xae'), ('ex', '\x45'), - ('ex', '\xc0'), ('ex', '\x2b')], - r'\__sqrt__': [('ex', '\x70'), ('ex', '\x71'), - ('ex', '\x72'), ('ex', '\x73')], - r'\backslash': [('ex', '\xb2'), ('ex', '\x2f'), - ('ex', '\xc2'), ('ex', '\x2d')], - r'/': [('rm', '/'), ('ex', '\xb1'), ('ex', '\x2e'), - ('ex', '\xcb'), ('ex', '\x2c')], - r'\widehat': [('rm', '\x5e'), ('ex', '\x62'), ('ex', '\x63'), - ('ex', '\x64')], - r'\widetilde': [('rm', '\x7e'), ('ex', '\x65'), ('ex', '\x66'), - ('ex', '\x67')], - r'<': [('cal', 'h'), ('ex', 'D')], - r'>': [('cal', 'i'), ('ex', 'E')] - } - - for alias, target in [(r'\leftparen', '('), - (r'\rightparent', ')'), - (r'\leftbrace', '{'), - (r'\rightbrace', '}'), - (r'\leftbracket', '['), - (r'\rightbracket', ']'), - (r'\{', '{'), - (r'\}', '}'), - (r'\[', '['), - (r'\]', ']')]: - _size_alternatives[alias] = _size_alternatives[target] - - def get_sized_alternatives_for_symbol(self, fontname, sym): - return self._size_alternatives.get(sym, [(fontname, sym)]) - - -class UnicodeFonts(TruetypeFonts): - """ - An abstract base class for handling Unicode fonts. - - While some reasonably complete Unicode fonts (such as DejaVu) may - work in some situations, the only Unicode font I'm aware of with a - complete set of math symbols is STIX. - - This class will "fallback" on the Bakoma fonts when a required - symbol can not be found in the font. - """ - - # Some glyphs are not present in the `cmr10` font, and must be brought in - # from `cmsy10`. Map the Unicode indices of those glyphs to the indices at - # which they are found in `cmsy10`. - _cmr10_substitutions = { - 0x00D7: 0x00A3, # Multiplication sign. - 0x2212: 0x00A1, # Minus sign. - } - - def __init__(self, *args, **kwargs): - # This must come first so the backend's owner is set correctly - fallback_rc = mpl.rcParams['mathtext.fallback'] - font_cls = {'stix': StixFonts, - 'stixsans': StixSansFonts, - 'cm': BakomaFonts - }.get(fallback_rc) - self._fallback_font = font_cls(*args, **kwargs) if font_cls else None - - super().__init__(*args, **kwargs) - self.fontmap = {} - for texfont in "cal rm tt it bf sf".split(): - prop = mpl.rcParams['mathtext.' + texfont] - font = findfont(prop) - self.fontmap[texfont] = font - prop = FontProperties('cmex10') - font = findfont(prop) - self.fontmap['ex'] = font - - # include STIX sized alternatives for glyphs if fallback is STIX - if isinstance(self._fallback_font, StixFonts): - stixsizedaltfonts = { - 0: 'STIXGeneral', - 1: 'STIXSizeOneSym', - 2: 'STIXSizeTwoSym', - 3: 'STIXSizeThreeSym', - 4: 'STIXSizeFourSym', - 5: 'STIXSizeFiveSym'} - - for size, name in stixsizedaltfonts.items(): - fullpath = findfont(name) - self.fontmap[size] = fullpath - self.fontmap[name] = fullpath - - _slanted_symbols = set(r"\int \oint".split()) - - def _map_virtual_font(self, fontname, font_class, uniindex): - return fontname, uniindex - - def _get_glyph(self, fontname, font_class, sym): - try: - uniindex = get_unicode_index(sym) - found_symbol = True - except ValueError: - uniindex = ord('?') - found_symbol = False - _log.warning("No TeX to Unicode mapping for {!a}.".format(sym)) - - fontname, uniindex = self._map_virtual_font( - fontname, font_class, uniindex) - - new_fontname = fontname - - # Only characters in the "Letter" class should be italicized in 'it' - # mode. Greek capital letters should be Roman. - if found_symbol: - if fontname == 'it' and uniindex < 0x10000: - char = chr(uniindex) - if (unicodedata.category(char)[0] != "L" - or unicodedata.name(char).startswith("GREEK CAPITAL")): - new_fontname = 'rm' - - slanted = (new_fontname == 'it') or sym in self._slanted_symbols - found_symbol = False - font = self._get_font(new_fontname) - if font is not None: - if (uniindex in self._cmr10_substitutions - and font.family_name == "cmr10"): - font = get_font( - cbook._get_data_path("fonts/ttf/cmsy10.ttf")) - uniindex = self._cmr10_substitutions[uniindex] - glyphindex = font.get_char_index(uniindex) - if glyphindex != 0: - found_symbol = True - - if not found_symbol: - if self._fallback_font: - if (fontname in ('it', 'regular') - and isinstance(self._fallback_font, StixFonts)): - fontname = 'rm' - - g = self._fallback_font._get_glyph(fontname, font_class, sym) - family = g[0].family_name - if family in list(BakomaFonts._fontmap.values()): - family = "Computer Modern" - _log.info("Substituting symbol %s from %s", sym, family) - return g - - else: - if (fontname in ('it', 'regular') - and isinstance(self, StixFonts)): - return self._get_glyph('rm', font_class, sym) - _log.warning("Font {!r} does not have a glyph for {!a} " - "[U+{:x}], substituting with a dummy " - "symbol.".format(new_fontname, sym, uniindex)) - font = self._get_font('rm') - uniindex = 0xA4 # currency char, for lack of anything better - slanted = False - - return font, uniindex, slanted - - def get_sized_alternatives_for_symbol(self, fontname, sym): - if self._fallback_font: - return self._fallback_font.get_sized_alternatives_for_symbol( - fontname, sym) - return [(fontname, sym)] - - -class DejaVuFonts(UnicodeFonts): - - def __init__(self, *args, **kwargs): - # This must come first so the backend's owner is set correctly - if isinstance(self, DejaVuSerifFonts): - self._fallback_font = StixFonts(*args, **kwargs) - else: - self._fallback_font = StixSansFonts(*args, **kwargs) - self.bakoma = BakomaFonts(*args, **kwargs) - TruetypeFonts.__init__(self, *args, **kwargs) - self.fontmap = {} - # Include Stix sized alternatives for glyphs - self._fontmap.update({ - 1: 'STIXSizeOneSym', - 2: 'STIXSizeTwoSym', - 3: 'STIXSizeThreeSym', - 4: 'STIXSizeFourSym', - 5: 'STIXSizeFiveSym', - }) - for key, name in self._fontmap.items(): - fullpath = findfont(name) - self.fontmap[key] = fullpath - self.fontmap[name] = fullpath - - def _get_glyph(self, fontname, font_class, sym): - # Override prime symbol to use Bakoma. - if sym == r'\prime': - return self.bakoma._get_glyph(fontname, font_class, sym) - else: - # check whether the glyph is available in the display font - uniindex = get_unicode_index(sym) - font = self._get_font('ex') - if font is not None: - glyphindex = font.get_char_index(uniindex) - if glyphindex != 0: - return super()._get_glyph('ex', font_class, sym) - # otherwise return regular glyph - return super()._get_glyph(fontname, font_class, sym) - - -class DejaVuSerifFonts(DejaVuFonts): - """ - A font handling class for the DejaVu Serif fonts - - If a glyph is not found it will fallback to Stix Serif - """ - _fontmap = { - 'rm': 'DejaVu Serif', - 'it': 'DejaVu Serif:italic', - 'bf': 'DejaVu Serif:weight=bold', - 'sf': 'DejaVu Sans', - 'tt': 'DejaVu Sans Mono', - 'ex': 'DejaVu Serif Display', - 0: 'DejaVu Serif', - } - - -class DejaVuSansFonts(DejaVuFonts): - """ - A font handling class for the DejaVu Sans fonts - - If a glyph is not found it will fallback to Stix Sans - """ - _fontmap = { - 'rm': 'DejaVu Sans', - 'it': 'DejaVu Sans:italic', - 'bf': 'DejaVu Sans:weight=bold', - 'sf': 'DejaVu Sans', - 'tt': 'DejaVu Sans Mono', - 'ex': 'DejaVu Sans Display', - 0: 'DejaVu Sans', - } - - -class StixFonts(UnicodeFonts): - """ - A font handling class for the STIX fonts. - - In addition to what UnicodeFonts provides, this class: - - - supports "virtual fonts" which are complete alpha numeric - character sets with different font styles at special Unicode - code points, such as "Blackboard". - - - handles sized alternative characters for the STIXSizeX fonts. - """ - _fontmap = { - 'rm': 'STIXGeneral', - 'it': 'STIXGeneral:italic', - 'bf': 'STIXGeneral:weight=bold', - 'nonunirm': 'STIXNonUnicode', - 'nonuniit': 'STIXNonUnicode:italic', - 'nonunibf': 'STIXNonUnicode:weight=bold', - 0: 'STIXGeneral', - 1: 'STIXSizeOneSym', - 2: 'STIXSizeTwoSym', - 3: 'STIXSizeThreeSym', - 4: 'STIXSizeFourSym', - 5: 'STIXSizeFiveSym', - } - _fallback_font = False - _sans = False - - def __init__(self, *args, **kwargs): - TruetypeFonts.__init__(self, *args, **kwargs) - self.fontmap = {} - for key, name in self._fontmap.items(): - fullpath = findfont(name) - self.fontmap[key] = fullpath - self.fontmap[name] = fullpath - - def _map_virtual_font(self, fontname, font_class, uniindex): - # Handle these "fonts" that are actually embedded in - # other fonts. - mapping = stix_virtual_fonts.get(fontname) - if (self._sans and mapping is None - and fontname not in ('regular', 'default')): - mapping = stix_virtual_fonts['sf'] - doing_sans_conversion = True - else: - doing_sans_conversion = False - - if mapping is not None: - if isinstance(mapping, dict): - try: - mapping = mapping[font_class] - except KeyError: - mapping = mapping['rm'] - - # Binary search for the source glyph - lo = 0 - hi = len(mapping) - while lo < hi: - mid = (lo+hi)//2 - range = mapping[mid] - if uniindex < range[0]: - hi = mid - elif uniindex <= range[1]: - break - else: - lo = mid + 1 - - if range[0] <= uniindex <= range[1]: - uniindex = uniindex - range[0] + range[3] - fontname = range[2] - elif not doing_sans_conversion: - # This will generate a dummy character - uniindex = 0x1 - fontname = mpl.rcParams['mathtext.default'] - - # Fix some incorrect glyphs. - if fontname in ('rm', 'it'): - uniindex = stix_glyph_fixes.get(uniindex, uniindex) - - # Handle private use area glyphs - if fontname in ('it', 'rm', 'bf') and 0xe000 <= uniindex <= 0xf8ff: - fontname = 'nonuni' + fontname - - return fontname, uniindex - - @functools.lru_cache() - def get_sized_alternatives_for_symbol(self, fontname, sym): - fixes = { - '\\{': '{', '\\}': '}', '\\[': '[', '\\]': ']', - '<': '\N{MATHEMATICAL LEFT ANGLE BRACKET}', - '>': '\N{MATHEMATICAL RIGHT ANGLE BRACKET}', - } - sym = fixes.get(sym, sym) - try: - uniindex = get_unicode_index(sym) - except ValueError: - return [(fontname, sym)] - alternatives = [(i, chr(uniindex)) for i in range(6) - if self._get_font(i).get_char_index(uniindex) != 0] - # The largest size of the radical symbol in STIX has incorrect - # metrics that cause it to be disconnected from the stem. - if sym == r'\__sqrt__': - alternatives = alternatives[:-1] - return alternatives - - -class StixSansFonts(StixFonts): - """ - A font handling class for the STIX fonts (that uses sans-serif - characters by default). - """ - _sans = True - - -############################################################################## -# TeX-LIKE BOX MODEL - -# The following is based directly on the document 'woven' from the -# TeX82 source code. This information is also available in printed -# form: -# -# Knuth, Donald E.. 1986. Computers and Typesetting, Volume B: -# TeX: The Program. Addison-Wesley Professional. -# -# The most relevant "chapters" are: -# Data structures for boxes and their friends -# Shipping pages out (ship()) -# Packaging (hpack() and vpack()) -# Data structures for math mode -# Subroutines for math mode -# Typesetting math formulas -# -# Many of the docstrings below refer to a numbered "node" in that -# book, e.g., node123 -# -# Note that (as TeX) y increases downward, unlike many other parts of -# matplotlib. - -# How much text shrinks when going to the next-smallest level. -SHRINK_FACTOR = 0.7 -# The number of different sizes of chars to use, beyond which they will not -# get any smaller -NUM_SIZE_LEVELS = 6 - - -class FontConstantsBase: - """ - A set of constants that controls how certain things, such as sub- - and superscripts are laid out. These are all metrics that can't - be reliably retrieved from the font metrics in the font itself. - """ - # Percentage of x-height of additional horiz. space after sub/superscripts - script_space = 0.05 - - # Percentage of x-height that sub/superscripts drop below the baseline - subdrop = 0.4 - - # Percentage of x-height that superscripts are raised from the baseline - sup1 = 0.7 - - # Percentage of x-height that subscripts drop below the baseline - sub1 = 0.3 - - # Percentage of x-height that subscripts drop below the baseline when a - # superscript is present - sub2 = 0.5 - - # Percentage of x-height that sub/superscripts are offset relative to the - # nucleus edge for non-slanted nuclei - delta = 0.025 - - # Additional percentage of last character height above 2/3 of the - # x-height that superscripts are offset relative to the subscript - # for slanted nuclei - delta_slanted = 0.2 - - # Percentage of x-height that superscripts and subscripts are offset for - # integrals - delta_integral = 0.1 - - -class ComputerModernFontConstants(FontConstantsBase): - script_space = 0.075 - subdrop = 0.2 - sup1 = 0.45 - sub1 = 0.2 - sub2 = 0.3 - delta = 0.075 - delta_slanted = 0.3 - delta_integral = 0.3 - - -class STIXFontConstants(FontConstantsBase): - script_space = 0.1 - sup1 = 0.8 - sub2 = 0.6 - delta = 0.05 - delta_slanted = 0.3 - delta_integral = 0.3 - - -class STIXSansFontConstants(FontConstantsBase): - script_space = 0.05 - sup1 = 0.8 - delta_slanted = 0.6 - delta_integral = 0.3 - - -class DejaVuSerifFontConstants(FontConstantsBase): - pass - - -class DejaVuSansFontConstants(FontConstantsBase): - pass - - -# Maps font family names to the FontConstantBase subclass to use -_font_constant_mapping = { - 'DejaVu Sans': DejaVuSansFontConstants, - 'DejaVu Sans Mono': DejaVuSansFontConstants, - 'DejaVu Serif': DejaVuSerifFontConstants, - 'cmb10': ComputerModernFontConstants, - 'cmex10': ComputerModernFontConstants, - 'cmmi10': ComputerModernFontConstants, - 'cmr10': ComputerModernFontConstants, - 'cmss10': ComputerModernFontConstants, - 'cmsy10': ComputerModernFontConstants, - 'cmtt10': ComputerModernFontConstants, - 'STIXGeneral': STIXFontConstants, - 'STIXNonUnicode': STIXFontConstants, - 'STIXSizeFiveSym': STIXFontConstants, - 'STIXSizeFourSym': STIXFontConstants, - 'STIXSizeThreeSym': STIXFontConstants, - 'STIXSizeTwoSym': STIXFontConstants, - 'STIXSizeOneSym': STIXFontConstants, - # Map the fonts we used to ship, just for good measure - 'Bitstream Vera Sans': DejaVuSansFontConstants, - 'Bitstream Vera': DejaVuSansFontConstants, - } - - -def _get_font_constant_set(state): - constants = _font_constant_mapping.get( - state.fontset._get_font(state.font).family_name, FontConstantsBase) - # STIX sans isn't really its own fonts, just different code points - # in the STIX fonts, so we have to detect this one separately. - if (constants is STIXFontConstants and - isinstance(state.fontset, StixSansFonts)): - return STIXSansFontConstants - return constants - - -class Node: - """A node in the TeX box model.""" - - def __init__(self): - self.size = 0 - - def __repr__(self): - return type(self).__name__ - - def get_kerning(self, next): - return 0.0 - - def shrink(self): - """ - Shrinks one level smaller. There are only three levels of - sizes, after which things will no longer get smaller. - """ - self.size += 1 - - def render(self, output, x, y): - """Render this node.""" - - -class Box(Node): - """A node with a physical location.""" - - def __init__(self, width, height, depth): - super().__init__() - self.width = width - self.height = height - self.depth = depth - - def shrink(self): - super().shrink() - if self.size < NUM_SIZE_LEVELS: - self.width *= SHRINK_FACTOR - self.height *= SHRINK_FACTOR - self.depth *= SHRINK_FACTOR - - def render(self, output, x1, y1, x2, y2): - pass - - -class Vbox(Box): - """A box with only height (zero width).""" - - def __init__(self, height, depth): - super().__init__(0., height, depth) - - -class Hbox(Box): - """A box with only width (zero height and depth).""" - - def __init__(self, width): - super().__init__(width, 0., 0.) - - -class Char(Node): - """ - A single character. - - Unlike TeX, the font information and metrics are stored with each `Char` - to make it easier to lookup the font metrics when needed. Note that TeX - boxes have a width, height, and depth, unlike Type1 and TrueType which use - a full bounding box and an advance in the x-direction. The metrics must - be converted to the TeX model, and the advance (if different from width) - must be converted into a `Kern` node when the `Char` is added to its parent - `Hlist`. - """ - - def __init__(self, c, state): - super().__init__() - self.c = c - self.fontset = state.fontset - self.font = state.font - self.font_class = state.font_class - self.fontsize = state.fontsize - self.dpi = state.dpi - # The real width, height and depth will be set during the - # pack phase, after we know the real fontsize - self._update_metrics() - - def __repr__(self): - return '`%s`' % self.c - - def _update_metrics(self): - metrics = self._metrics = self.fontset.get_metrics( - self.font, self.font_class, self.c, self.fontsize, self.dpi) - if self.c == ' ': - self.width = metrics.advance - else: - self.width = metrics.width - self.height = metrics.iceberg - self.depth = -(metrics.iceberg - metrics.height) - - def is_slanted(self): - return self._metrics.slanted - - def get_kerning(self, next): - """ - Return the amount of kerning between this and the given character. - - This method is called when characters are strung together into `Hlist` - to create `Kern` nodes. - """ - advance = self._metrics.advance - self.width - kern = 0. - if isinstance(next, Char): - kern = self.fontset.get_kern( - self.font, self.font_class, self.c, self.fontsize, - next.font, next.font_class, next.c, next.fontsize, - self.dpi) - return advance + kern - - def render(self, output, x, y): - self.fontset.render_glyph( - output, x, y, - self.font, self.font_class, self.c, self.fontsize, self.dpi) - - def shrink(self): - super().shrink() - if self.size < NUM_SIZE_LEVELS: - self.fontsize *= SHRINK_FACTOR - self.width *= SHRINK_FACTOR - self.height *= SHRINK_FACTOR - self.depth *= SHRINK_FACTOR - - -class Accent(Char): - """ - The font metrics need to be dealt with differently for accents, - since they are already offset correctly from the baseline in - TrueType fonts. - """ - def _update_metrics(self): - metrics = self._metrics = self.fontset.get_metrics( - self.font, self.font_class, self.c, self.fontsize, self.dpi) - self.width = metrics.xmax - metrics.xmin - self.height = metrics.ymax - metrics.ymin - self.depth = 0 - - def shrink(self): - super().shrink() - self._update_metrics() - - def render(self, output, x, y): - self.fontset.render_glyph( - output, x - self._metrics.xmin, y + self._metrics.ymin, - self.font, self.font_class, self.c, self.fontsize, self.dpi) - - -class List(Box): - """A list of nodes (either horizontal or vertical).""" - - def __init__(self, elements): - super().__init__(0., 0., 0.) - self.shift_amount = 0. # An arbitrary offset - self.children = elements # The child nodes of this list - # The following parameters are set in the vpack and hpack functions - self.glue_set = 0. # The glue setting of this list - self.glue_sign = 0 # 0: normal, -1: shrinking, 1: stretching - self.glue_order = 0 # The order of infinity (0 - 3) for the glue - - def __repr__(self): - return '%s DataPC DX11 AC3 Homestead.forge
Download ✒ https://gohhs.com/2uFSYs
- -luat si eu azi assasins creed III si cand se instaleaza imi da urmatorile erori:1)crc roor datapc dx11 ac3 boston.forge 2)crc eroor datapc . dx11 ac3 boston. -3) crc instaleaza imi da urmatorile erori: boston. -4) crc instaleaza imi da ur mnitorul ani eror: boston. -5) crc instaleaza imi da urmatorile erori: boston. -6) crc instaleaza imi da urmatorile erori: boston. -7) crc instaleaza imi da urmatorile erori: boston. -8) crc instaleaza imi da urmatorile erori: boston. -9) crc instaleaza imi da urmatorile erori: boston. -10) crc instaleaza imi da urmatorile 8a78ff9644
-
-
- diff --git a/spaces/diacanFperku/AutoGPT/Korg Pa Manager V3 With Crack REPACK.md b/spaces/diacanFperku/AutoGPT/Korg Pa Manager V3 With Crack REPACK.md deleted file mode 100644 index e4954727ce59cee2381f9051748313b2f47c6b6e..0000000000000000000000000000000000000000 --- a/spaces/diacanFperku/AutoGPT/Korg Pa Manager V3 With Crack REPACK.md +++ /dev/null @@ -1,6 +0,0 @@ -Korg pa manager v3 With Crack
DOWNLOAD >>> https://gohhs.com/2uFTrf
- -7 Jan 2022 - KORG PA Manager Crack is a good and user friendly software. This professional software helps you to process many music files. You can use this software for professional or amateur use. It has many features such as file management, synthesizer management, MIDI management, MIDI settings management and more. The program has a multilingual interface that is very easy to use. You can also use it as a music editor or music player. This software is for you to enjoy music easily. 8a78ff9644
-
-
- diff --git a/spaces/diagaiwei/ir_chinese_medqa/README.md b/spaces/diagaiwei/ir_chinese_medqa/README.md deleted file mode 100644 index 2de3798f5a72ca09f270879db39709b07dbd6565..0000000000000000000000000000000000000000 --- a/spaces/diagaiwei/ir_chinese_medqa/README.md +++ /dev/null @@ -1,13 +0,0 @@ ---- -title: Ir Chinese Medqa -emoji: 📉 -colorFrom: yellow -colorTo: indigo -sdk: gradio -sdk_version: 3.5 -app_file: app.py -pinned: false -license: openrail ---- - -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference diff --git a/spaces/diego2554/RemBG_super/rembg/session_cloth.py b/spaces/diego2554/RemBG_super/rembg/session_cloth.py deleted file mode 100644 index 11bcef74378be4d64058772c29ac45240f60a85b..0000000000000000000000000000000000000000 --- a/spaces/diego2554/RemBG_super/rembg/session_cloth.py +++ /dev/null @@ -1,88 +0,0 @@ -from typing import List - -import numpy as np -from PIL import Image -from PIL.Image import Image as PILImage -from scipy.special import log_softmax - -from .session_base import BaseSession - -pallete1 = [ - 0, - 0, - 0, - 255, - 255, - 255, - 0, - 0, - 0, - 0, - 0, - 0, -] - -pallete2 = [ - 0, - 0, - 0, - 0, - 0, - 0, - 255, - 255, - 255, - 0, - 0, - 0, -] - -pallete3 = [ - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 255, - 255, - 255, -] - - -class ClothSession(BaseSession): - def predict(self, img: PILImage) -> List[PILImage]: - ort_outs = self.inner_session.run( - None, self.normalize(img, (0.5, 0.5, 0.5), (0.5, 0.5, 0.5), (768, 768)) - ) - - pred = ort_outs - pred = log_softmax(pred[0], 1) - pred = np.argmax(pred, axis=1, keepdims=True) - pred = np.squeeze(pred, 0) - pred = np.squeeze(pred, 0) - - mask = Image.fromarray(pred.astype("uint8"), mode="L") - mask = mask.resize(img.size, Image.LANCZOS) - - masks = [] - - mask1 = mask.copy() - mask1.putpalette(pallete1) - mask1 = mask1.convert("RGB").convert("L") - masks.append(mask1) - - mask2 = mask.copy() - mask2.putpalette(pallete2) - mask2 = mask2.convert("RGB").convert("L") - masks.append(mask2) - - mask3 = mask.copy() - mask3.putpalette(pallete3) - mask3 = mask3.convert("RGB").convert("L") - masks.append(mask3) - - return masks diff --git a/spaces/digitalxingtong/Bufeiyan-a-Bert-VITS2/monotonic_align/setup.py b/spaces/digitalxingtong/Bufeiyan-a-Bert-VITS2/monotonic_align/setup.py deleted file mode 100644 index 30c224807a70faa9df9c9eb75f8e80c8c867b16b..0000000000000000000000000000000000000000 --- a/spaces/digitalxingtong/Bufeiyan-a-Bert-VITS2/monotonic_align/setup.py +++ /dev/null @@ -1,9 +0,0 @@ -from distutils.core import setup -from Cython.Build import cythonize -import numpy - -setup( - name = 'monotonic_align', - ext_modules = cythonize("core.pyx"), - include_dirs=[numpy.get_include()] -) diff --git a/spaces/digitalxingtong/Miiu-Bert-Vits2/transcribe_genshin.py b/spaces/digitalxingtong/Miiu-Bert-Vits2/transcribe_genshin.py deleted file mode 100644 index acc98814af6189d129ab85946525bec55419a33f..0000000000000000000000000000000000000000 --- a/spaces/digitalxingtong/Miiu-Bert-Vits2/transcribe_genshin.py +++ /dev/null @@ -1,78 +0,0 @@ -# coding=gbk -import os -import argparse -import librosa -import numpy as np -from multiprocessing import Pool, cpu_count - -import soundfile -from scipy.io import wavfile -from tqdm import tqdm - -global speaker_annos -speaker_annos = [] - -def process(item): - spkdir, wav_name, args = item - speaker = spkdir.replace("\\", "/").split("/")[-1] - wav_path = os.path.join(args.in_dir, speaker, wav_name) - if os.path.exists(wav_path) and '.wav' in wav_path: - os.makedirs(os.path.join(args.out_dir, speaker), exist_ok=True) - wav, sr = librosa.load(wav_path, sr=args.sr) - soundfile.write( - os.path.join(args.out_dir, speaker, wav_name), - wav, - sr - ) - -def process_text(item): - spkdir, wav_name, args = item - speaker = spkdir.replace("\\", "/").split("/")[-1] - wav_path = os.path.join(args.in_dir, speaker, wav_name) - global speaker_annos - tr_name = wav_name.replace('.wav', '') - with open(args.out_dir+'/'+speaker+'/'+tr_name+'.lab', "r", encoding="utf-8") as file: - text = file.read() - text = text.replace("{NICKNAME}",'') - text = text.replace("{M#}{F#}",'') - text = text.replace("{M#}{F#}",'') - substring = "{M#}{F#}" - if substring in text: - if tr_name.endswith("a"): - text = text.replace("{M#}{F#}",'') - if tr_name.endswith("b"): - text = text.replace("{M#}{F#}",'') - text = text.replace("#",'') - text = "ZH|" + text + "\n" # - speaker_annos.append(args.out_dir+'/'+speaker+'/'+wav_name+ "|" + speaker + "|" + text) - - - -if __name__ == "__main__": - parent_dir = "./genshin_dataset/" - speaker_names = list(os.walk(parent_dir))[0][1] - parser = argparse.ArgumentParser() - parser.add_argument("--sr", type=int, default=44100, help="sampling rate") - parser.add_argument("--in_dir", type=str, default="./genshin_dataset", help="path to source dir") - parser.add_argument("--out_dir", type=str, default="./genshin_dataset", help="path to target dir") - args = parser.parse_args() - # processs = 8 - processs = cpu_count()-2 if cpu_count() >4 else 1 - pool = Pool(processes=processs) - - for speaker in os.listdir(args.in_dir): - spk_dir = os.path.join(args.in_dir, speaker) - if os.path.isdir(spk_dir): - print(spk_dir) - for _ in tqdm(pool.imap_unordered(process, [(spk_dir, i, args) for i in os.listdir(spk_dir) if i.endswith("wav")])): - pass - for i in os.listdir(spk_dir): - if i.endswith("wav"): - pro=(spk_dir, i, args) - process_text(pro) - if len(speaker_annos) == 0: - print("transcribe error!!!") - with open("./filelists/short_character_anno.list", 'w', encoding='utf-8') as f: - for line in speaker_annos: - f.write(line) - print("transcript file finished.") diff --git a/spaces/digitalxingtong/Xingtong-2dall-Bert-VITS2/text/english.py b/spaces/digitalxingtong/Xingtong-2dall-Bert-VITS2/text/english.py deleted file mode 100644 index 781d0a56cef71f66fc67db51d76538be90d3ddd2..0000000000000000000000000000000000000000 --- a/spaces/digitalxingtong/Xingtong-2dall-Bert-VITS2/text/english.py +++ /dev/null @@ -1,138 +0,0 @@ -import pickle -import os -import re -from g2p_en import G2p -from string import punctuation - -from text import symbols - -current_file_path = os.path.dirname(__file__) -CMU_DICT_PATH = os.path.join(current_file_path, 'cmudict.rep') -CACHE_PATH = os.path.join(current_file_path, 'cmudict_cache.pickle') -_g2p = G2p() - -arpa = {'AH0', 'S', 'AH1', 'EY2', 'AE2', 'EH0', 'OW2', 'UH0', 'NG', 'B', 'G', 'AY0', 'M', 'AA0', 'F', 'AO0', 'ER2', 'UH1', 'IY1', 'AH2', 'DH', 'IY0', 'EY1', 'IH0', 'K', 'N', 'W', 'IY2', 'T', 'AA1', 'ER1', 'EH2', 'OY0', 'UH2', 'UW1', 'Z', 'AW2', 'AW1', 'V', 'UW2', 'AA2', 'ER', 'AW0', 'UW0', 'R', 'OW1', 'EH1', 'ZH', 'AE0', 'IH2', 'IH', 'Y', 'JH', 'P', 'AY1', 'EY0', 'OY2', 'TH', 'HH', 'D', 'ER0', 'CH', 'AO1', 'AE1', 'AO2', 'OY1', 'AY2', 'IH1', 'OW0', 'L', 'SH'} - - -def post_replace_ph(ph): - rep_map = { - '：': ',', - '；': ',', - '，': ',', - '。': '.', - '！': '!', - '？': '?', - '\n': '.', - "·": ",", - '、': ",", - '...': '…', - 'v': "V" - } - if ph in rep_map.keys(): - ph = rep_map[ph] - if ph in symbols: - return ph - if ph not in symbols: - ph = 'UNK' - return ph - -def read_dict(): - g2p_dict = {} - start_line = 49 - with open(CMU_DICT_PATH) as f: - line = f.readline() - line_index = 1 - while line: - if line_index >= start_line: - line = line.strip() - word_split = line.split(' ') - word = word_split[0] - - syllable_split = word_split[1].split(' - ') - g2p_dict[word] = [] - for syllable in syllable_split: - phone_split = syllable.split(' ') - g2p_dict[word].append(phone_split) - - line_index = line_index + 1 - line = f.readline() - - return g2p_dict - - -def cache_dict(g2p_dict, file_path): - with open(file_path, 'wb') as pickle_file: - pickle.dump(g2p_dict, pickle_file) - - -def get_dict(): - if os.path.exists(CACHE_PATH): - with open(CACHE_PATH, 'rb') as pickle_file: - g2p_dict = pickle.load(pickle_file) - else: - g2p_dict = read_dict() - cache_dict(g2p_dict, CACHE_PATH) - - return g2p_dict - -eng_dict = get_dict() - -def refine_ph(phn): - tone = 0 - if re.search(r'\d$', phn): - tone = int(phn[-1]) + 1 - phn = phn[:-1] - return phn.lower(), tone - -def refine_syllables(syllables): - tones = [] - phonemes = [] - for phn_list in syllables: - for i in range(len(phn_list)): - phn = phn_list[i] - phn, tone = refine_ph(phn) - phonemes.append(phn) - tones.append(tone) - return phonemes, tones - - -def text_normalize(text): - # todo: eng text normalize - return text - -def g2p(text): - - phones = [] - tones = [] - words = re.split(r"([,;.\-\?\!\s+])", text) - for w in words: - if w.upper() in eng_dict: - phns, tns = refine_syllables(eng_dict[w.upper()]) - phones += phns - tones += tns - else: - phone_list = list(filter(lambda p: p != " ", _g2p(w))) - for ph in phone_list: - if ph in arpa: - ph, tn = refine_ph(ph) - phones.append(ph) - tones.append(tn) - else: - phones.append(ph) - tones.append(0) - # todo: implement word2ph - word2ph = [1 for i in phones] - - phones = [post_replace_ph(i) for i in phones] - return phones, tones, word2ph - -if __name__ == "__main__": - # print(get_dict()) - # print(eng_word_to_phoneme("hello")) - print(g2p("In this paper, we propose 1 DSPGAN, a GAN-based universal vocoder.")) - # all_phones = set() - # for k, syllables in eng_dict.items(): - # for group in syllables: - # for ph in group: - # all_phones.add(ph) - # print(all_phones) \ No newline at end of file diff --git a/spaces/dineshreddy/WALT/mmdet/core/bbox/samplers/instance_balanced_pos_sampler.py b/spaces/dineshreddy/WALT/mmdet/core/bbox/samplers/instance_balanced_pos_sampler.py deleted file mode 100644 index c735298487e14e4a0ec42913f25673cccb98a8a0..0000000000000000000000000000000000000000 --- a/spaces/dineshreddy/WALT/mmdet/core/bbox/samplers/instance_balanced_pos_sampler.py +++ /dev/null @@ -1,55 +0,0 @@ -import numpy as np -import torch - -from ..builder import BBOX_SAMPLERS -from .random_sampler import RandomSampler - - -@BBOX_SAMPLERS.register_module() -class InstanceBalancedPosSampler(RandomSampler): - """Instance balanced sampler that samples equal number of positive samples - for each instance.""" - - def _sample_pos(self, assign_result, num_expected, **kwargs): - """Sample positive boxes. - - Args: - assign_result (:obj:`AssignResult`): The assigned results of boxes. - num_expected (int): The number of expected positive samples - - Returns: - Tensor or ndarray: sampled indices. - """ - pos_inds = torch.nonzero(assign_result.gt_inds > 0, as_tuple=False) - if pos_inds.numel() != 0: - pos_inds = pos_inds.squeeze(1) - if pos_inds.numel() <= num_expected: - return pos_inds - else: - unique_gt_inds = assign_result.gt_inds[pos_inds].unique() - num_gts = len(unique_gt_inds) - num_per_gt = int(round(num_expected / float(num_gts)) + 1) - sampled_inds = [] - for i in unique_gt_inds: - inds = torch.nonzero( - assign_result.gt_inds == i.item(), as_tuple=False) - if inds.numel() != 0: - inds = inds.squeeze(1) - else: - continue - if len(inds) > num_per_gt: - inds = self.random_choice(inds, num_per_gt) - sampled_inds.append(inds) - sampled_inds = torch.cat(sampled_inds) - if len(sampled_inds) < num_expected: - num_extra = num_expected - len(sampled_inds) - extra_inds = np.array( - list(set(pos_inds.cpu()) - set(sampled_inds.cpu()))) - if len(extra_inds) > num_extra: - extra_inds = self.random_choice(extra_inds, num_extra) - extra_inds = torch.from_numpy(extra_inds).to( - assign_result.gt_inds.device).long() - sampled_inds = torch.cat([sampled_inds, extra_inds]) - elif len(sampled_inds) > num_expected: - sampled_inds = self.random_choice(sampled_inds, num_expected) - return sampled_inds diff --git a/spaces/dineshreddy/WALT/mmdet/models/losses/iou_loss.py b/spaces/dineshreddy/WALT/mmdet/models/losses/iou_loss.py deleted file mode 100644 index eba6f18b80981ca891c1add37007e6bf478c651f..0000000000000000000000000000000000000000 --- a/spaces/dineshreddy/WALT/mmdet/models/losses/iou_loss.py +++ /dev/null @@ -1,436 +0,0 @@ -import math - -import mmcv -import torch -import torch.nn as nn - -from mmdet.core import bbox_overlaps -from ..builder import LOSSES -from .utils import weighted_loss - - -@mmcv.jit(derivate=True, coderize=True) -@weighted_loss -def iou_loss(pred, target, linear=False, eps=1e-6): - """IoU loss. - - Computing the IoU loss between a set of predicted bboxes and target bboxes. - The loss is calculated as negative log of IoU. - - Args: - pred (torch.Tensor): Predicted bboxes of format (x1, y1, x2, y2), - shape (n, 4). - target (torch.Tensor): Corresponding gt bboxes, shape (n, 4). - linear (bool, optional): If True, use linear scale of loss instead of - log scale. Default: False. - eps (float): Eps to avoid log(0). - - Return: - torch.Tensor: Loss tensor. - """ - ious = bbox_overlaps(pred, target, is_aligned=True).clamp(min=eps) - if linear: - loss = 1 - ious - else: - loss = -ious.log() - return loss - - -@mmcv.jit(derivate=True, coderize=True) -@weighted_loss -def bounded_iou_loss(pred, target, beta=0.2, eps=1e-3): - """BIoULoss. - - This is an implementation of paper - `Improving Object Localization with Fitness NMS and Bounded IoU Loss. -- - diff --git a/spaces/editing-images/ai-halloween-photobooth/pipeline_semantic_stable_diffusion_xl_img2img_ddpm.py b/spaces/editing-images/ai-halloween-photobooth/pipeline_semantic_stable_diffusion_xl_img2img_ddpm.py deleted file mode 100644 index bd126c85461f2a27b0ff256c1cde018d02474533..0000000000000000000000000000000000000000 --- a/spaces/editing-images/ai-halloween-photobooth/pipeline_semantic_stable_diffusion_xl_img2img_ddpm.py +++ /dev/null @@ -1,1763 +0,0 @@ -# Copyright 2023 The HuggingFace Team. All rights reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import inspect -import os -#from itertools import repeat -from typing import Any, Callable, Dict, List, Optional, Tuple, Union -import numpy as np -from PIL import Image -from tqdm import tqdm -import torch.nn.functional as F -import math - -import torch -from transformers import CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer - -from diffusers.image_processor import VaeImageProcessor -from diffusers.loaders import FromSingleFileMixin, LoraLoaderMixin, TextualInversionLoaderMixin -from diffusers.models import AutoencoderKL, UNet2DConditionModel -from diffusers.models.attention_processor import ( - AttnProcessor2_0, - LoRAAttnProcessor2_0, - LoRAXFormersAttnProcessor, - XFormersAttnProcessor, - AttnProcessor, - Attention -) -from diffusers.schedulers import DDIMScheduler -from diffusers.utils import ( - is_accelerate_available, - is_accelerate_version, - is_invisible_watermark_available, - logging, - # randn_tensor, - replace_example_docstring, -) - -from diffusers.utils.torch_utils import randn_tensor -from diffusers.pipeline_utils import DiffusionPipeline -from diffusers.pipelines.stable_diffusion_xl import StableDiffusionXLPipelineOutput - - -if is_invisible_watermark_available(): - from diffusers.pipelines.stable_diffusion_xl.watermark import StableDiffusionXLWatermarker - - -logger = logging.get_logger(__name__) # pylint: disable=invalid-name - -EXAMPLE_DOC_STRING = """ - Examples: - ```py - >>> import torch - >>> from diffusers import StableDiffusionXLPipeline - - >>> pipe = StableDiffusionXLPipeline.from_pretrained( - ... "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16 - ... ) - >>> pipe = pipe.to("cuda") - - >>> prompt = "a photo of an astronaut riding a horse on mars" - >>> image = pipe(prompt).images[0] - ``` -""" - - -class AttentionStore(): - @staticmethod - def get_empty_store(): - return {"down_cross": [], "mid_cross": [], "up_cross": [], - "down_self": [], "mid_self": [], "up_self": []} - - def __call__(self, attn, is_cross: bool, place_in_unet: str, editing_prompts): - # attn.shape = batch_size * head_size, seq_len query, seq_len_key - bs = 2 + editing_prompts - source_batch_size = int(attn.shape[0] // bs) - skip = 1 # skip unconditional - self.forward( - attn[skip*source_batch_size:], - is_cross, - place_in_unet) - - def forward(self, attn, is_cross: bool, place_in_unet: str): - key = f"{place_in_unet}_{'cross' if is_cross else 'self'}" - #print(f"{key} : {attn.shape[1]}") - self.step_store[key].append(attn) - - def between_steps(self, store_step=True): - if store_step: - if self.average: - if len(self.attention_store) == 0: - self.attention_store = self.step_store - else: - for key in self.attention_store: - for i in range(len(self.attention_store[key])): - self.attention_store[key][i] += self.step_store[key][i] - else: - if len(self.attention_store) == 0: - self.attention_store = [self.step_store] - else: - self.attention_store.append(self.step_store) - - self.cur_step += 1 - self.step_store = self.get_empty_store() - - def get_attention(self, step: int): - if self.average: - attention = {key: [item / self.cur_step for item in self.attention_store[key]] for key in self.attention_store} - else: - assert(step is not None) - attention = self.attention_store[step] - return attention - - def aggregate_attention(self, attention_maps, prompts, res: int, - from_where: List[str], is_cross: bool, select: int - ): - out = [] - num_pixels = res ** 2 - for location in from_where: - for item in attention_maps[f"{location}_{'cross' if is_cross else 'self'}"]: - if item.shape[1] == num_pixels: - cross_maps = item.reshape(len(prompts), -1, res, res, item.shape[-1])[select] - out.append(cross_maps) - out = torch.cat(out, dim=0) - # average over heads - out = out.sum(0) / out.shape[0] - return out - - def __init__(self, average: bool): - self.step_store = self.get_empty_store() - self.attention_store = [] - self.cur_step = 0 - self.average = average - -class CrossAttnProcessor: - - def __init__(self, attention_store, place_in_unet, editing_prompts): - self.attnstore = attention_store - self.place_in_unet = place_in_unet - self.editing_prompts = editing_prompts - - def __call__( - self, - attn: Attention, - hidden_states, - encoder_hidden_states=None, - attention_mask=None, - temb=None, - ): - assert(not attn.residual_connection) - assert(attn.spatial_norm is None) - assert(attn.group_norm is None) - assert(hidden_states.ndim != 4) - assert(encoder_hidden_states is not None) # is cross - - batch_size, sequence_length, _ = ( - hidden_states.shape if encoder_hidden_states is None else encoder_hidden_states.shape - ) - attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length, batch_size) - - query = attn.to_q(hidden_states) - - if encoder_hidden_states is None: - encoder_hidden_states = hidden_states - elif attn.norm_cross: - encoder_hidden_states = attn.norm_encoder_hidden_states(encoder_hidden_states) - - key = attn.to_k(encoder_hidden_states) - value = attn.to_v(encoder_hidden_states) - - query = attn.head_to_batch_dim(query) - key = attn.head_to_batch_dim(key) - value = attn.head_to_batch_dim(value) - - attention_probs = attn.get_attention_scores(query, key, attention_mask) - self.attnstore(attention_probs, - is_cross=True, - place_in_unet=self.place_in_unet, - editing_prompts=self.editing_prompts) - - hidden_states = torch.bmm(attention_probs, value) - hidden_states = attn.batch_to_head_dim(hidden_states) - - # linear proj - hidden_states = attn.to_out[0](hidden_states) - # dropout - hidden_states = attn.to_out[1](hidden_states) - - hidden_states = hidden_states / attn.rescale_output_factor - return hidden_states - - -# Modified from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionAttendAndExcitePipeline.GaussianSmoothing -class GaussianSmoothing(): - - def __init__(self, device): - kernel_size = [3, 3] - sigma = [0.5, 0.5] - - # The gaussian kernel is the product of the gaussian function of each dimension. - kernel = 1 - meshgrids = torch.meshgrid([torch.arange(size, dtype=torch.float32) for size in kernel_size]) - for size, std, mgrid in zip(kernel_size, sigma, meshgrids): - mean = (size - 1) / 2 - kernel *= 1 / (std * math.sqrt(2 * math.pi)) * torch.exp(-(((mgrid - mean) / (2 * std)) ** 2)) - - # Make sure sum of values in gaussian kernel equals 1. - kernel = kernel / torch.sum(kernel) - - # Reshape to depthwise convolutional weight - kernel = kernel.view(1, 1, *kernel.size()) - kernel = kernel.repeat(1, *[1] * (kernel.dim() - 1)) - - self.weight = kernel.to(device) - - def __call__(self, input): - """ - Arguments: - Apply gaussian filter to input. - input (torch.Tensor): Input to apply gaussian filter on. - Returns: - filtered (torch.Tensor): Filtered output. - """ - return F.conv2d(input, weight=self.weight.to(input.dtype)) - - -def load_image(image_path, size=1024, left=0, right=0, top=0, bottom=0, device=None, dtype=None): - print(f"load image of size {size}x{size}") - if type(image_path) is str: - image = np.array(Image.open(image_path).convert('RGB'))[:, :, :3] - else: - image = image_path - h, w, c = image.shape - left = min(left, w-1) - right = min(right, w - left - 1) - top = min(top, h - left - 1) - bottom = min(bottom, h - top - 1) - image = image[top:h-bottom, left:w-right] - h, w, c = image.shape - if h < w: - offset = (w - h) // 2 - image = image[:, offset:offset + h] - elif w < h: - offset = (h - w) // 2 - image = image[offset:offset + w] - image = np.array(Image.fromarray(image).resize((size, size))) - image = torch.from_numpy(image).float() / 127.5 - 1 - image = image.permute(2, 0, 1).unsqueeze(0) - - image = image.to(device=device, dtype=dtype) - return image - -# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.rescale_noise_cfg -def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0): - """ - Rescale `noise_cfg` according to `guidance_rescale`. Based on findings of [Common Diffusion Noise Schedules and - Sample Steps are Flawed](https://arxiv.org/pdf/2305.08891.pdf). See Section 3.4 - """ - std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True) - std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True) - # rescale the results from guidance (fixes overexposure) - noise_pred_rescaled = noise_cfg * (std_text / std_cfg) - # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images - noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg - return noise_cfg - - -class SemanticStableDiffusionXLImg2ImgPipeline_DDPMInversion(DiffusionPipeline, FromSingleFileMixin, LoraLoaderMixin): - r""" - Pipeline for text-to-image generation using Stable Diffusion XL. - - This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the - library implements for all the pipelines (such as downloading or saving, running on a particular device, etc.) - - In addition the pipeline inherits the following loading methods: - - *LoRA*: [`StableDiffusionXLPipeline.load_lora_weights`] - - *Ckpt*: [`loaders.FromSingleFileMixin.from_single_file`] - - as well as the following saving methods: - - *LoRA*: [`loaders.StableDiffusionXLPipeline.save_lora_weights`] - - Args: - vae ([`AutoencoderKL`]): - Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations. - text_encoder ([`CLIPTextModel`]): - Frozen text-encoder. Stable Diffusion XL uses the text portion of - [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), specifically - the [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14) variant. - text_encoder_2 ([` CLIPTextModelWithProjection`]): - Second frozen text-encoder. Stable Diffusion XL uses the text and pool portion of - [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection), - specifically the - [laion/CLIP-ViT-bigG-14-laion2B-39B-b160k](https://huggingface.co/laion/CLIP-ViT-bigG-14-laion2B-39B-b160k) - variant. - tokenizer (`CLIPTokenizer`): - Tokenizer of class - [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). - tokenizer_2 (`CLIPTokenizer`): - Second Tokenizer of class - [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). - unet ([`UNet2DConditionModel`]): Conditional U-Net architecture to denoise the encoded image latents. - scheduler ([`SchedulerMixin`]): - A scheduler to be used in combination with `unet` to denoise the encoded image latents. Can be one of - [`DDIMScheduler`], [`LMSDiscreteScheduler`], or [`PNDMScheduler`]. - """ - - def __init__( - self, - vae: AutoencoderKL, - text_encoder: CLIPTextModel, - text_encoder_2: CLIPTextModelWithProjection, - tokenizer: CLIPTokenizer, - tokenizer_2: CLIPTokenizer, - unet: UNet2DConditionModel, - scheduler: DDIMScheduler, - force_zeros_for_empty_prompt: bool = True, - add_watermarker: Optional[bool] = None, - ): - super().__init__() - - if not isinstance(scheduler, DDIMScheduler): - scheduler = DDIMScheduler.from_config(scheduler.config) - logger.warning("This pipeline only supports DDIMScheduler. " - "The scheduler has been changed to DDIMScheduler.") - - self.register_modules( - vae=vae, - text_encoder=text_encoder, - text_encoder_2=text_encoder_2, - tokenizer=tokenizer, - tokenizer_2=tokenizer_2, - unet=unet, - scheduler=scheduler, - ) - self.register_to_config(force_zeros_for_empty_prompt=force_zeros_for_empty_prompt) - self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1) - self.image_processor = VaeImageProcessor(vae_scale_factor=self.vae_scale_factor) - self.default_sample_size = self.unet.config.sample_size - - add_watermarker = add_watermarker if add_watermarker is not None else is_invisible_watermark_available() - - if add_watermarker: - self.watermark = StableDiffusionXLWatermarker() - else: - self.watermark = None - - # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.enable_vae_slicing - def enable_vae_slicing(self): - r""" - Enable sliced VAE decoding. When this option is enabled, the VAE will split the input tensor in slices to - compute decoding in several steps. This is useful to save some memory and allow larger batch sizes. - """ - self.vae.enable_slicing() - - # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.disable_vae_slicing - def disable_vae_slicing(self): - r""" - Disable sliced VAE decoding. If `enable_vae_slicing` was previously enabled, this method will go back to - computing decoding in one step. - """ - self.vae.disable_slicing() - - # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.enable_vae_tiling - def enable_vae_tiling(self): - r""" - Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to - compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow - processing larger images. - """ - self.vae.enable_tiling() - - # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.disable_vae_tiling - def disable_vae_tiling(self): - r""" - Disable tiled VAE decoding. If `enable_vae_tiling` was previously enabled, this method will go back to - computing decoding in one step. - """ - self.vae.disable_tiling() - - def enable_model_cpu_offload(self, gpu_id=0): - r""" - Offloads all models to CPU using accelerate, reducing memory usage with a low impact on performance. Compared - to `enable_sequential_cpu_offload`, this method moves one whole model at a time to the GPU when its `forward` - method is called, and the model remains in GPU until the next model runs. Memory savings are lower than with - `enable_sequential_cpu_offload`, but performance is much better due to the iterative execution of the `unet`. - """ - if is_accelerate_available() and is_accelerate_version(">=", "0.17.0.dev0"): - from accelerate import cpu_offload_with_hook - else: - raise ImportError("`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.") - - device = torch.device(f"cuda:{gpu_id}") - - if self.device.type != "cpu": - self.to("cpu", silence_dtype_warnings=True) - torch.cuda.empty_cache() # otherwise we don't see the memory savings (but they probably exist) - - model_sequence = ( - [self.text_encoder, self.text_encoder_2] if self.text_encoder is not None else [self.text_encoder_2] - ) - model_sequence.extend([self.unet, self.vae]) - - hook = None - for cpu_offloaded_model in model_sequence: - _, hook = cpu_offload_with_hook(cpu_offloaded_model, device, prev_module_hook=hook) - - # We'll offload the last model manually. - self.final_offload_hook = hook - - def encode_prompt( - self, - prompt: str, - prompt_2: Optional[str] = None, - device: Optional[torch.device] = None, - num_images_per_prompt: int = 1, - do_classifier_free_guidance: bool = True, - negative_prompt: Optional[str] = None, - negative_prompt_2: Optional[str] = None, - prompt_embeds: Optional[torch.FloatTensor] = None, - negative_prompt_embeds: Optional[torch.FloatTensor] = None, - pooled_prompt_embeds: Optional[torch.FloatTensor] = None, - negative_pooled_prompt_embeds: Optional[torch.FloatTensor] = None, - lora_scale: Optional[float] = None, - enable_edit_guidance: bool = True, - editing_prompt: Optional[str] = None, - ): - r""" - Encodes the prompt into text encoder hidden states. - - Args: - prompt (`str` or `List[str]`, *optional*): - prompt to be encoded - prompt_2 (`str` or `List[str]`, *optional*): - The prompt or prompts to be sent to the `tokenizer_2` and `text_encoder_2`. If not defined, `prompt` is - used in both text-encoders - device: (`torch.device`): - torch device - num_images_per_prompt (`int`): - number of images that should be generated per prompt - do_classifier_free_guidance (`bool`): - whether to use classifier free guidance or not - negative_prompt (`str` or `List[str]`, *optional*): - The prompt or prompts not to guide the image generation. If not defined, one has to pass - `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is - less than `1`). - negative_prompt_2 (`str` or `List[str]`, *optional*): - The prompt or prompts not to guide the image generation to be sent to `tokenizer_2` and - `text_encoder_2`. If not defined, `negative_prompt` is used in both text-encoders - prompt_embeds (`torch.FloatTensor`, *optional*): - Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not - provided, text embeddings will be generated from `prompt` input argument. - negative_prompt_embeds (`torch.FloatTensor`, *optional*): - Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt - weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input - argument. - pooled_prompt_embeds (`torch.FloatTensor`, *optional*): - Pre-generated pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. - If not provided, pooled text embeddings will be generated from `prompt` input argument. - negative_pooled_prompt_embeds (`torch.FloatTensor`, *optional*): - Pre-generated negative pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt - weighting. If not provided, pooled negative_prompt_embeds will be generated from `negative_prompt` - input argument. - lora_scale (`float`, *optional*): - A lora scale that will be applied to all LoRA layers of the text encoder if LoRA layers are loaded. - """ - device = device or self._execution_device - - # set lora scale so that monkey patched LoRA - # function of text encoder can correctly access it - if lora_scale is not None and isinstance(self, LoraLoaderMixin): - self._lora_scale = lora_scale - - if prompt is not None and isinstance(prompt, str): - batch_size = 1 - elif prompt is not None and isinstance(prompt, list): - batch_size = len(prompt) - else: - batch_size = prompt_embeds.shape[0] - - # Define tokenizers and text encoders - tokenizers = [self.tokenizer, self.tokenizer_2] if self.tokenizer is not None else [self.tokenizer_2] - text_encoders = ( - [self.text_encoder, self.text_encoder_2] if self.text_encoder is not None else [self.text_encoder_2] - ) - - if prompt_embeds is None: - prompt_2 = prompt_2 or prompt - # textual inversion: procecss multi-vector tokens if necessary - prompt_embeds_list = [] - prompts = [prompt, prompt_2] - for prompt, tokenizer, text_encoder in zip(prompts, tokenizers, text_encoders): - if isinstance(self, TextualInversionLoaderMixin): - prompt = self.maybe_convert_prompt(prompt, tokenizer) - - text_inputs = tokenizer( - prompt, - padding="max_length", - max_length=tokenizer.model_max_length, - truncation=True, - return_tensors="pt", - ) - - text_input_ids = text_inputs.input_ids - untruncated_ids = tokenizer(prompt, padding="longest", return_tensors="pt").input_ids - - if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal( - text_input_ids, untruncated_ids - ): - removed_text = tokenizer.batch_decode(untruncated_ids[:, tokenizer.model_max_length - 1 : -1]) - logger.warning( - "The following part of your input was truncated because CLIP can only handle sequences up to" - f" {tokenizer.model_max_length} tokens: {removed_text}" - ) - - prompt_embeds = text_encoder( - text_input_ids.to(device), - output_hidden_states=True, - ) - - # We are only ALWAYS interested in the pooled output of the final text encoder - pooled_prompt_embeds = prompt_embeds[0] - prompt_embeds = prompt_embeds.hidden_states[-2] - - prompt_embeds_list.append(prompt_embeds) - - prompt_embeds = torch.concat(prompt_embeds_list, dim=-1) - - # get unconditional embeddings for classifier free guidance - zero_out_negative_prompt = negative_prompt is None and self.config.force_zeros_for_empty_prompt - if do_classifier_free_guidance and negative_prompt_embeds is None and zero_out_negative_prompt: - negative_prompt_embeds = torch.zeros_like(prompt_embeds) - negative_pooled_prompt_embeds = torch.zeros_like(pooled_prompt_embeds) - elif do_classifier_free_guidance and negative_prompt_embeds is None: - negative_prompt = negative_prompt or "" - negative_prompt_2 = negative_prompt_2 or negative_prompt - - uncond_tokens: List[str] - if prompt is not None and type(prompt) is not type(negative_prompt): - raise TypeError( - f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !=" - f" {type(prompt)}." - ) - elif isinstance(negative_prompt, str): - uncond_tokens = [negative_prompt, negative_prompt_2] - elif batch_size != len(negative_prompt): - raise ValueError( - f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:" - f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches" - " the batch size of `prompt`." - ) - else: - uncond_tokens = [negative_prompt, negative_prompt_2] - - negative_prompt_embeds_list = [] - for negative_prompt, tokenizer, text_encoder in zip(uncond_tokens, tokenizers, text_encoders): - if isinstance(self, TextualInversionLoaderMixin): - negative_prompt = self.maybe_convert_prompt(negative_prompt, tokenizer) - - max_length = prompt_embeds.shape[1] - uncond_input = tokenizer( - negative_prompt, - padding="max_length", - max_length=max_length, - truncation=True, - return_tensors="pt", - ) - - negative_prompt_embeds = text_encoder( - uncond_input.input_ids.to(device), - output_hidden_states=True, - ) - # We are only ALWAYS interested in the pooled output of the final text encoder - negative_pooled_prompt_embeds = negative_prompt_embeds[0] - negative_prompt_embeds = negative_prompt_embeds.hidden_states[-2] - - negative_prompt_embeds_list.append(negative_prompt_embeds) - - negative_prompt_embeds = torch.concat(negative_prompt_embeds_list, dim=-1) - - num_edit_tokens = None - if enable_edit_guidance: - editing_prompt_2 = editing_prompt - - editing_prompts = [editing_prompt, editing_prompt_2] - edit_prompt_embeds_list = [] - - for editing_prompt, tokenizer, text_encoder in zip(editing_prompts, tokenizers, text_encoders): - if isinstance(self, TextualInversionLoaderMixin): - editing_prompt = self.maybe_convert_prompt(editing_prompt, tokenizer) - - max_length = prompt_embeds.shape[1] - edit_concepts_input = tokenizer( - #[x for item in editing_prompt for x in repeat(item, batch_size)], - editing_prompt, - padding="max_length", - max_length=max_length, - truncation=True, - return_tensors="pt", - return_length=True - ) - - num_edit_tokens = edit_concepts_input.length -2 # not counting startoftext and endoftext - edit_concepts_input_ids = edit_concepts_input.input_ids - edit_concepts_embeds = text_encoder( - edit_concepts_input.input_ids.to(device), - output_hidden_states=True, - ) - # We are only ALWAYS interested in the pooled output of the final text encoder - edit_pooled_prompt_embeds = edit_concepts_embeds[0] - edit_concepts_embeds = edit_concepts_embeds.hidden_states[-2] - - edit_prompt_embeds_list.append(edit_concepts_embeds) - - edit_concepts_embeds = torch.concat(edit_prompt_embeds_list, dim=-1) - else: - edit_concepts_embeds = None - edit_pooled_prompt_embeds = None - - prompt_embeds = prompt_embeds.to(dtype=self.text_encoder_2.dtype, device=device) - bs_embed, seq_len, _ = prompt_embeds.shape - # duplicate text embeddings for each generation per prompt, using mps friendly method - prompt_embeds = prompt_embeds.repeat(1, num_images_per_prompt, 1) - prompt_embeds = prompt_embeds.view(bs_embed * num_images_per_prompt, seq_len, -1) - - if do_classifier_free_guidance: - # duplicate unconditional embeddings for each generation per prompt, using mps friendly method - seq_len = negative_prompt_embeds.shape[1] - negative_prompt_embeds = negative_prompt_embeds.to(dtype=self.text_encoder_2.dtype, device=device) - negative_prompt_embeds = negative_prompt_embeds.repeat(1, num_images_per_prompt, 1) - negative_prompt_embeds = negative_prompt_embeds.view(batch_size * num_images_per_prompt, seq_len, -1) - - if enable_edit_guidance: - bs_embed_edit, seq_len, _ = edit_concepts_embeds.shape - edit_concepts_embeds = edit_concepts_embeds.to(dtype=self.text_encoder_2.dtype, device=device) - edit_concepts_embeds = edit_concepts_embeds.repeat(1, num_images_per_prompt, 1) - edit_concepts_embeds = edit_concepts_embeds.view(bs_embed_edit * num_images_per_prompt, seq_len, -1) - - pooled_prompt_embeds = pooled_prompt_embeds.repeat(1, num_images_per_prompt).view( - bs_embed * num_images_per_prompt, -1 - ) - if do_classifier_free_guidance: - negative_pooled_prompt_embeds = negative_pooled_prompt_embeds.repeat(1, num_images_per_prompt).view( - bs_embed * num_images_per_prompt, -1 - ) - - if enable_edit_guidance: - edit_pooled_prompt_embeds = edit_pooled_prompt_embeds.repeat(1, num_images_per_prompt).view( - bs_embed_edit * num_images_per_prompt, -1 - ) - - return (prompt_embeds, negative_prompt_embeds, edit_concepts_embeds, - pooled_prompt_embeds, negative_pooled_prompt_embeds, edit_pooled_prompt_embeds, - num_edit_tokens) - - # Modified from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_extra_step_kwargs - def prepare_extra_step_kwargs(self, eta): - # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature - # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. - # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 - # and should be between [0, 1] - - accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys()) - extra_step_kwargs = {} - if accepts_eta: - extra_step_kwargs["eta"] = eta - - return extra_step_kwargs - - def check_inputs( - self, - prompt, - prompt_2, - height, - width, - callback_steps, - negative_prompt=None, - negative_prompt_2=None, - prompt_embeds=None, - negative_prompt_embeds=None, - pooled_prompt_embeds=None, - negative_pooled_prompt_embeds=None, - ): - if height % 8 != 0 or width % 8 != 0: - raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.") - - if (callback_steps is None) or ( - callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0) - ): - raise ValueError( - f"`callback_steps` has to be a positive integer but is {callback_steps} of type" - f" {type(callback_steps)}." - ) - - if prompt is not None and prompt_embeds is not None: - raise ValueError( - f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to" - " only forward one of the two." - ) - elif prompt_2 is not None and prompt_embeds is not None: - raise ValueError( - f"Cannot forward both `prompt_2`: {prompt_2} and `prompt_embeds`: {prompt_embeds}. Please make sure to" - " only forward one of the two." - ) - elif prompt is None and prompt_embeds is None: - raise ValueError( - "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined." - ) - elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)): - raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}") - elif prompt_2 is not None and (not isinstance(prompt_2, str) and not isinstance(prompt_2, list)): - raise ValueError(f"`prompt_2` has to be of type `str` or `list` but is {type(prompt_2)}") - - if negative_prompt is not None and negative_prompt_embeds is not None: - raise ValueError( - f"Cannot forward both `negative_prompt`: {negative_prompt} and `negative_prompt_embeds`:" - f" {negative_prompt_embeds}. Please make sure to only forward one of the two." - ) - elif negative_prompt_2 is not None and negative_prompt_embeds is not None: - raise ValueError( - f"Cannot forward both `negative_prompt_2`: {negative_prompt_2} and `negative_prompt_embeds`:" - f" {negative_prompt_embeds}. Please make sure to only forward one of the two." - ) - - if prompt_embeds is not None and negative_prompt_embeds is not None: - if prompt_embeds.shape != negative_prompt_embeds.shape: - raise ValueError( - "`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but" - f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`" - f" {negative_prompt_embeds.shape}." - ) - - if prompt_embeds is not None and pooled_prompt_embeds is None: - raise ValueError( - "If `prompt_embeds` are provided, `pooled_prompt_embeds` also have to be passed. Make sure to generate `pooled_prompt_embeds` from the same text encoder that was used to generate `prompt_embeds`." - ) - - if negative_prompt_embeds is not None and negative_pooled_prompt_embeds is None: - raise ValueError( - "If `negative_prompt_embeds` are provided, `negative_pooled_prompt_embeds` also have to be passed. Make sure to generate `negative_pooled_prompt_embeds` from the same text encoder that was used to generate `negative_prompt_embeds`." - ) - - # Modified from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_latents - def prepare_latents(self, batch_size, num_channels_latents, height, width, dtype, device, latents): - shape = (batch_size, num_channels_latents, height // self.vae_scale_factor, width // self.vae_scale_factor) - - if latents.shape != shape: - raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {shape}") - - latents = latents.to(device) - - # scale the initial noise by the standard deviation required by the scheduler - latents = latents * self.scheduler.init_noise_sigma - return latents - - def prepare_unet(self, attention_store, enabled_editing_prompts): - attn_procs = {} - for name in self.unet.attn_processors.keys(): - if name.startswith("mid_block"): - place_in_unet = "mid" - elif name.startswith("up_blocks"): - place_in_unet = "up" - elif name.startswith("down_blocks"): - place_in_unet = "down" - else: - continue - - if "attn2" in name: - attn_procs[name] = CrossAttnProcessor( - attention_store=attention_store, - place_in_unet=place_in_unet, - editing_prompts=enabled_editing_prompts) - else: - attn_procs[name] = AttnProcessor() - - self.unet.set_attn_processor(attn_procs) - - - def _get_add_time_ids(self, original_size, crops_coords_top_left, target_size, dtype): - add_time_ids = list(original_size + crops_coords_top_left + target_size) - - passed_add_embed_dim = ( - self.unet.config.addition_time_embed_dim * len(add_time_ids) + self.text_encoder_2.config.projection_dim - ) - expected_add_embed_dim = self.unet.add_embedding.linear_1.in_features - - if expected_add_embed_dim != passed_add_embed_dim: - raise ValueError( - f"Model expects an added time embedding vector of length {expected_add_embed_dim}, but a vector of {passed_add_embed_dim} was created. The model has an incorrect config. Please check `unet.config.time_embedding_type` and `text_encoder_2.config.projection_dim`." - ) - - add_time_ids = torch.tensor([add_time_ids], dtype=dtype) - return add_time_ids - - # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_upscale.StableDiffusionUpscalePipeline.upcast_vae - def upcast_vae(self): - dtype = self.vae.dtype - self.vae.to(dtype=torch.float32) - use_torch_2_0_or_xformers = isinstance( - self.vae.decoder.mid_block.attentions[0].processor, - ( - AttnProcessor2_0, - XFormersAttnProcessor, - LoRAXFormersAttnProcessor, - LoRAAttnProcessor2_0, - ), - ) - # if xformers or torch_2_0 is used attention block does not need - # to be in float32 which can save lots of memory - if use_torch_2_0_or_xformers: - self.vae.post_quant_conv.to(dtype) - self.vae.decoder.conv_in.to(dtype) - self.vae.decoder.mid_block.to(dtype) - - @torch.no_grad() - @replace_example_docstring(EXAMPLE_DOC_STRING) - def __call__( - self, - prompt: Union[str, List[str]] = None, - prompt_2: Optional[Union[str, List[str]]] = None, - height: Optional[int] = None, - width: Optional[int] = None, - num_inference_steps: int = 50, - #denoising_end: Optional[float] = None, - guidance_scale: float = 5.0, - negative_prompt: Optional[Union[str, List[str]]] = None, - negative_prompt_2: Optional[Union[str, List[str]]] = None, - #num_images_per_prompt: Optional[int] = 1, - eta: float = 1.0, - #generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None, - latents: Optional[torch.FloatTensor] = None, - prompt_embeds: Optional[torch.FloatTensor] = None, - negative_prompt_embeds: Optional[torch.FloatTensor] = None, - pooled_prompt_embeds: Optional[torch.FloatTensor] = None, - negative_pooled_prompt_embeds: Optional[torch.FloatTensor] = None, - output_type: Optional[str] = "pil", - return_dict: bool = True, - callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None, - callback_steps: int = 1, - cross_attention_kwargs: Optional[Dict[str, Any]] = None, - guidance_rescale: float = 0.0, - original_size: Optional[Tuple[int, int]] = None, - crops_coords_top_left: Tuple[int, int] = (0, 0), - target_size: Optional[Tuple[int, int]] = None, - editing_prompt: Optional[Union[str, List[str]]] = None, - editing_prompt_embeddings: Optional[torch.Tensor] = None, - reverse_editing_direction: Optional[Union[bool, List[bool]]] = False, - edit_guidance_scale: Optional[Union[float, List[float]]] = 5, - edit_warmup_steps: Optional[Union[int, List[int]]] = 10, - edit_cooldown_steps: Optional[Union[int, List[int]]] = None, - edit_threshold: Optional[Union[float, List[float]]] = 0.9, - edit_momentum_scale: Optional[float] = 0.1, - edit_mom_beta: Optional[float] = 0.4, - edit_weights: Optional[List[float]] = None, - sem_guidance: Optional[List[torch.Tensor]] = None, - user_mask: Optional[torch.FloatTensor] = None, - use_cross_attn_mask: bool = False, - # Attention store (just for visualization purposes) - attn_store_steps: Optional[List[int]] = [], - store_averaged_over_steps: bool = True, - - zs: Optional[torch.FloatTensor] = None, - wts: Optional[torch.FloatTensor] = None, - ): - r""" - Function invoked when calling the pipeline for generation. - - Args: - prompt (`str` or `List[str]`, *optional*): - The prompt or prompts to guide the image generation. If not defined, one has to pass `prompt_embeds`. - instead. - prompt_2 (`str` or `List[str]`, *optional*): - The prompt or prompts to be sent to the `tokenizer_2` and `text_encoder_2`. If not defined, `prompt` is - used in both text-encoders - height (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor): - The height in pixels of the generated image. - width (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor): - The width in pixels of the generated image. - num_inference_steps (`int`, *optional*, defaults to 50): - The number of denoising steps. More denoising steps usually lead to a higher quality image at the - expense of slower inference. - denoising_end (`float`, *optional*): - When specified, determines the fraction (between 0.0 and 1.0) of the total denoising process to be - completed before it is intentionally prematurely terminated. As a result, the returned sample will - still retain a substantial amount of noise as determined by the discrete timesteps selected by the - scheduler. The denoising_end parameter should ideally be utilized when this pipeline forms a part of a - "Mixture of Denoisers" multi-pipeline setup, as elaborated in [**Refining the Image - Output**](https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion/stable_diffusion_xl#refining-the-image-output) - guidance_scale (`float`, *optional*, defaults to 5.0): - Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598). - `guidance_scale` is defined as `w` of equation 2. of [Imagen - Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale > - 1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`, - usually at the expense of lower image quality. - negative_prompt (`str` or `List[str]`, *optional*): - The prompt or prompts not to guide the image generation. If not defined, one has to pass - `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is - less than `1`). - negative_prompt_2 (`str` or `List[str]`, *optional*): - The prompt or prompts not to guide the image generation to be sent to `tokenizer_2` and - `text_encoder_2`. If not defined, `negative_prompt` is used in both text-encoders - num_images_per_prompt (`int`, *optional*, defaults to 1): - The number of images to generate per prompt. - eta (`float`, *optional*, defaults to 0.0): - Corresponds to parameter eta (η) in the DDIM paper: https://arxiv.org/abs/2010.02502. Only applies to - [`schedulers.DDIMScheduler`], will be ignored for others. - generator (`torch.Generator` or `List[torch.Generator]`, *optional*): - One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html) - to make generation deterministic. - latents (`torch.FloatTensor`, *optional*): - Pre-generated noisy latents, sampled from a Gaussian distribution, to be used as inputs for image - generation. Can be used to tweak the same generation with different prompts. If not provided, a latents - tensor will ge generated by sampling using the supplied random `generator`. - prompt_embeds (`torch.FloatTensor`, *optional*): - Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not - provided, text embeddings will be generated from `prompt` input argument. - negative_prompt_embeds (`torch.FloatTensor`, *optional*): - Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt - weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input - argument. - pooled_prompt_embeds (`torch.FloatTensor`, *optional*): - Pre-generated pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. - If not provided, pooled text embeddings will be generated from `prompt` input argument. - negative_pooled_prompt_embeds (`torch.FloatTensor`, *optional*): - Pre-generated negative pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt - weighting. If not provided, pooled negative_prompt_embeds will be generated from `negative_prompt` - input argument. - output_type (`str`, *optional*, defaults to `"pil"`): - The output format of the generate image. Choose between - [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`. - return_dict (`bool`, *optional*, defaults to `True`): - Whether or not to return a [`~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput`] instead - of a plain tuple. - callback (`Callable`, *optional*): - A function that will be called every `callback_steps` steps during inference. The function will be - called with the following arguments: `callback(step: int, timestep: int, latents: torch.FloatTensor)`. - callback_steps (`int`, *optional*, defaults to 1): - The frequency at which the `callback` function will be called. If not specified, the callback will be - called at every step. - cross_attention_kwargs (`dict`, *optional*): - A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under - `self.processor` in - [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). - guidance_rescale (`float`, *optional*, defaults to 0.7): - Guidance rescale factor proposed by [Common Diffusion Noise Schedules and Sample Steps are - Flawed](https://arxiv.org/pdf/2305.08891.pdf) `guidance_scale` is defined as `φ` in equation 16. of - [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://arxiv.org/pdf/2305.08891.pdf). - Guidance rescale factor should fix overexposure when using zero terminal SNR. - original_size (`Tuple[int]`, *optional*, defaults to (1024, 1024)): - If `original_size` is not the same as `target_size` the image will appear to be down- or upsampled. - `original_size` defaults to `(width, height)` if not specified. Part of SDXL's micro-conditioning as - explained in section 2.2 of - [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). - crops_coords_top_left (`Tuple[int]`, *optional*, defaults to (0, 0)): - `crops_coords_top_left` can be used to generate an image that appears to be "cropped" from the position - `crops_coords_top_left` downwards. Favorable, well-centered images are usually achieved by setting - `crops_coords_top_left` to (0, 0). Part of SDXL's micro-conditioning as explained in section 2.2 of - [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). - target_size (`Tuple[int]`, *optional*, defaults to (1024, 1024)): - For most cases, `target_size` should be set to the desired height and width of the generated image. If - not specified it will default to `(width, height)`. Part of SDXL's micro-conditioning as explained in - section 2.2 of [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). - editing_prompt (`str` or `List[str]`, *optional*): - The prompt or prompts to use for semantic guidance. Semantic guidance is disabled by setting - `editing_prompt = None`. Guidance direction of prompt should be specified via - `reverse_editing_direction`. - editing_prompt_embeddings (`torch.Tensor`, *optional*): - Pre-computed embeddings to use for semantic guidance. Guidance direction of embedding should be - specified via `reverse_editing_direction`. - reverse_editing_direction (`bool` or `List[bool]`, *optional*, defaults to `False`): - Whether the corresponding prompt in `editing_prompt` should be increased or decreased. - edit_guidance_scale (`float` or `List[float]`, *optional*, defaults to 5): - Guidance scale for semantic guidance. If provided as a list, values should correspond to - `editing_prompt`. - edit_warmup_steps (`float` or `List[float]`, *optional*, defaults to 10): - Number of diffusion steps (for each prompt) for which semantic guidance is not applied. Momentum is - calculated for those steps and applied once all warmup periods are over. - edit_cooldown_steps (`float` or `List[float]`, *optional*, defaults to `None`): - Number of diffusion steps (for each prompt) after which semantic guidance is longer applied. - edit_threshold (`float` or `List[float]`, *optional*, defaults to 0.9): - Threshold of semantic guidance. - edit_momentum_scale (`float`, *optional*, defaults to 0.1): - Scale of the momentum to be added to the semantic guidance at each diffusion step. If set to 0.0, - momentum is disabled. Momentum is already built up during warmup (for diffusion steps smaller than - `sld_warmup_steps`). Momentum is only added to latent guidance once all warmup periods are finished. - edit_mom_beta (`float`, *optional*, defaults to 0.4): - Defines how semantic guidance momentum builds up. `edit_mom_beta` indicates how much of the previous - momentum is kept. Momentum is already built up during warmup (for diffusion steps smaller than - `edit_warmup_steps`). - edit_weights (`List[float]`, *optional*, defaults to `None`): - Indicates how much each individual concept should influence the overall guidance. If no weights are - provided all concepts are applied equally. - sem_guidance (`List[torch.Tensor]`, *optional*): - List of pre-generated guidance vectors to be applied at generation. Length of the list has to - correspond to `num_inference_steps`. - - Examples: - - Returns: - [`~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput`] or `tuple`: - [`~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput`] if `return_dict` is True, otherwise a - `tuple`. When returning a tuple, the first element is a list with the generated images. - """ - # eta = self.eta - # num_inference_steps = self.num_inversion_steps - num_images_per_prompt = 1 - # latents = self.init_latents - - use_ddpm = True - # zs = self.zs - # wts = self.wts - - if use_cross_attn_mask: - self.smoothing = GaussianSmoothing(self.device) - - # 0. Default height and width to unet - # height = self.height - # width = self.width - # original_size = self.original_size - # target_size = self.target_size - - height = height or self.default_sample_size * self.vae_scale_factor - width = width or self.default_sample_size * self.vae_scale_factor - original_size = original_size or (height, width) - target_size = target_size or (height, width) - - # 1. Check inputs. Raise error if not correct - self.check_inputs( - prompt, - prompt_2, - height, - width, - callback_steps, - negative_prompt, - negative_prompt_2, - prompt_embeds, - negative_prompt_embeds, - pooled_prompt_embeds, - negative_pooled_prompt_embeds, - ) - - # 2. Define call parameters - if prompt is not None and isinstance(prompt, str): - batch_size = 1 - elif prompt is not None and isinstance(prompt, list): - batch_size = len(prompt) - else: - batch_size = prompt_embeds.shape[0] - - device = self._execution_device - - if editing_prompt: - enable_edit_guidance = True - if isinstance(editing_prompt, str): - editing_prompt = [editing_prompt] - enabled_editing_prompts = len(editing_prompt) - elif editing_prompt_embeddings is not None: - enable_edit_guidance = True - enabled_editing_prompts = editing_prompt_embeddings.shape[0] - else: - enabled_editing_prompts = 0 - enable_edit_guidance = False - - # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) - # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1` - # corresponds to doing no classifier free guidance. - do_classifier_free_guidance = guidance_scale > 1.0 - - if prompt == "" and (prompt_2 == "" or prompt_2 is None): - # only use uncond noise pred - guidance_scale = 0.0 - do_classifier_free_guidance = True - else: - do_classifier_free_guidance = guidance_scale > 1.0 - - # 3. Encode input prompt - text_encoder_lora_scale = ( - cross_attention_kwargs.get("scale", None) if cross_attention_kwargs is not None else None - ) - ( - prompt_embeds, - negative_prompt_embeds, - edit_prompt_embeds, - pooled_prompt_embeds, - negative_pooled_prompt_embeds, - pooled_edit_embeds, - num_edit_tokens - ) = self.encode_prompt( - prompt=prompt, - prompt_2=prompt_2, - device=device, - num_images_per_prompt=num_images_per_prompt, - do_classifier_free_guidance=do_classifier_free_guidance, - negative_prompt=negative_prompt, - negative_prompt_2=negative_prompt_2, - prompt_embeds=prompt_embeds, - negative_prompt_embeds=negative_prompt_embeds, - pooled_prompt_embeds=pooled_prompt_embeds, - negative_pooled_prompt_embeds=negative_pooled_prompt_embeds, - lora_scale=text_encoder_lora_scale, - enable_edit_guidance=enable_edit_guidance, - editing_prompt=editing_prompt - ) - - # 4. Prepare timesteps - self.scheduler.set_timesteps(num_inference_steps, device=device) - - timesteps = self.scheduler.timesteps - if use_ddpm: - t_to_idx = {int(v):k for k,v in enumerate(timesteps[-zs.shape[0]:])} - timesteps = timesteps[-zs.shape[0]:] - - self.attention_store = AttentionStore(average=store_averaged_over_steps) - # self.prepare_unet(self.attention_store, enabled_editing_prompts) - - # 5. Prepare latent variables - num_channels_latents = self.unet.config.in_channels - latents = self.prepare_latents( - batch_size * num_images_per_prompt, - num_channels_latents, - height, - width, - prompt_embeds.dtype, - device, - latents, - ) - - if user_mask is not None: - user_mask = user_mask.to(self.device) - assert(latents.shape[-2:] == user_mask.shape) - - # 6. Prepare extra step kwargs. - extra_step_kwargs = self.prepare_extra_step_kwargs(eta) - - # 7. Prepare added time ids & embeddings - add_text_embeds = pooled_prompt_embeds - add_time_ids = self._get_add_time_ids( - original_size, crops_coords_top_left, target_size, dtype=prompt_embeds.dtype - ) - - self.text_cross_attention_maps = [prompt] if isinstance(prompt, str) else prompt - if enable_edit_guidance: - prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds, edit_prompt_embeds], dim=0) - add_text_embeds = torch.cat([negative_pooled_prompt_embeds, add_text_embeds, pooled_edit_embeds], dim=0) - edit_concepts_time_ids = add_time_ids.repeat(edit_prompt_embeds.shape[0], 1) - add_time_ids = torch.cat([add_time_ids, add_time_ids, edit_concepts_time_ids], dim=0) - - self.text_cross_attention_maps += \ - ([editing_prompt] if isinstance(editing_prompt, str) else editing_prompt) - elif do_classifier_free_guidance: - prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0) - add_text_embeds = torch.cat([negative_pooled_prompt_embeds, add_text_embeds], dim=0) - add_time_ids = torch.cat([add_time_ids, add_time_ids], dim=0) - - prompt_embeds = prompt_embeds.to(device) - add_text_embeds = add_text_embeds.to(device) - add_time_ids = add_time_ids.to(device).repeat(batch_size * num_images_per_prompt, 1) - - # 8. Denoising loop - edit_momentum = None - self.uncond_estimates = None - self.text_estimates = None - self.edit_estimates = None - self.sem_guidance = None - - with self.progress_bar(total=len(timesteps)) as progress_bar: - for i, t in enumerate(timesteps): - # expand the latents if we are doing classifier free guidance - latent_model_input = ( - torch.cat([latents] * (2 + enabled_editing_prompts)) if do_classifier_free_guidance else latents - ) - latent_model_input = self.scheduler.scale_model_input(latent_model_input, t) - - # predict the noise residual - added_cond_kwargs = {"text_embeds": add_text_embeds, "time_ids": add_time_ids} - noise_pred = self.unet( - latent_model_input, - t, - encoder_hidden_states=prompt_embeds, - cross_attention_kwargs=cross_attention_kwargs, - added_cond_kwargs=added_cond_kwargs, - return_dict=False, - )[0] - - # perform guidance - if do_classifier_free_guidance: - noise_pred_out = noise_pred.chunk(2 + enabled_editing_prompts) # [b,4, 64, 64] - noise_pred_uncond, noise_pred_text = noise_pred_out[0], noise_pred_out[1] - noise_pred_edit_concepts = noise_pred_out[2:] - - #noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) - noise_guidance = guidance_scale * (noise_pred_text - noise_pred_uncond) - - if self.uncond_estimates is None: - self.uncond_estimates = torch.zeros((len(timesteps), *noise_pred_uncond.shape)) - self.uncond_estimates[i] = noise_pred_uncond.detach().cpu() - - if self.text_estimates is None: - self.text_estimates = torch.zeros((len(timesteps), *noise_pred_text.shape)) - self.text_estimates[i] = noise_pred_text.detach().cpu() - - if self.edit_estimates is None and enable_edit_guidance: - self.edit_estimates = torch.zeros( - (len(timesteps), len(noise_pred_edit_concepts), *noise_pred_edit_concepts[0].shape) - ) - - if self.sem_guidance is None: - self.sem_guidance = torch.zeros((len(timesteps), *noise_pred_text.shape)) - - if edit_momentum is None: - edit_momentum = torch.zeros_like(noise_guidance) - - if enable_edit_guidance: - concept_weights = torch.zeros( - (len(noise_pred_edit_concepts), noise_guidance.shape[0]), - device=self.device, - dtype=noise_guidance.dtype, - ) - noise_guidance_edit = torch.zeros( - (len(noise_pred_edit_concepts), *noise_guidance.shape), - device=self.device, - dtype=noise_guidance.dtype, - ) - # noise_guidance_edit = torch.zeros_like(noise_guidance) - warmup_inds = [] - for c, noise_pred_edit_concept in enumerate(noise_pred_edit_concepts): - self.edit_estimates[i, c] = noise_pred_edit_concept - if isinstance(edit_guidance_scale, list): - edit_guidance_scale_c = edit_guidance_scale[c] - else: - edit_guidance_scale_c = edit_guidance_scale - - if isinstance(edit_threshold, list): - edit_threshold_c = edit_threshold[c] - else: - edit_threshold_c = edit_threshold - if isinstance(reverse_editing_direction, list): - reverse_editing_direction_c = reverse_editing_direction[c] - else: - reverse_editing_direction_c = reverse_editing_direction - if edit_weights: - edit_weight_c = edit_weights[c] - else: - edit_weight_c = 1.0 - if isinstance(edit_warmup_steps, list): - edit_warmup_steps_c = edit_warmup_steps[c] - else: - edit_warmup_steps_c = edit_warmup_steps - - if isinstance(edit_cooldown_steps, list): - edit_cooldown_steps_c = edit_cooldown_steps[c] - elif edit_cooldown_steps is None: - edit_cooldown_steps_c = i + 1 - else: - edit_cooldown_steps_c = edit_cooldown_steps - if i >= edit_warmup_steps_c: - warmup_inds.append(c) - if i >= edit_cooldown_steps_c: - noise_guidance_edit[c, :, :, :, :] = torch.zeros_like(noise_pred_edit_concept) - continue - - noise_guidance_edit_tmp = noise_pred_edit_concept - noise_pred_uncond - # tmp_weights = (noise_pred_text - noise_pred_edit_concept).sum(dim=(1, 2, 3)) - tmp_weights = (noise_guidance - noise_pred_edit_concept).sum(dim=(1, 2, 3)) - - tmp_weights = torch.full_like(tmp_weights, edit_weight_c) # * (1 / enabled_editing_prompts) - if reverse_editing_direction_c: - noise_guidance_edit_tmp = noise_guidance_edit_tmp * -1 - concept_weights[c, :] = tmp_weights - - noise_guidance_edit_tmp = noise_guidance_edit_tmp * edit_guidance_scale_c - - if user_mask is not None: - noise_guidance_edit_tmp = noise_guidance_edit_tmp * user_mask - - if use_cross_attn_mask: - out = self.attention_store.aggregate_attention( - attention_maps=self.attention_store.step_store, - prompts=self.text_cross_attention_maps, - res=32, - from_where=["up","down"], - is_cross=True, - select=self.text_cross_attention_maps.index(editing_prompt[c]), - ) - - attn_map = out[:, :, 1:1+num_edit_tokens[c]] # 0 -> startoftext - - # average over all tokens - assert(attn_map.shape[2]==num_edit_tokens[c]) - attn_map = torch.sum(attn_map, dim=2) - - # gaussian_smoothing - attn_map = F.pad(attn_map.unsqueeze(0).unsqueeze(0), (1, 1, 1, 1), mode="reflect") - attn_map = self.smoothing(attn_map).squeeze(0).squeeze(0) - - # create binary mask - # torch.quantile function expects float32 - if attn_map.dtype == torch.float32: - tmp = torch.quantile( - attn_map.flatten(), - edit_threshold_c - ) - else: - tmp = torch.quantile( - attn_map.flatten().to(torch.float32), - edit_threshold_c - ).to(attn_map.dtype) - - attn_mask = torch.where(attn_map >= tmp, 1.0, 0.0) - - # resolution must match latent space dimension - attn_mask = F.interpolate( - attn_mask.unsqueeze(0).unsqueeze(0), - noise_guidance_edit_tmp.shape[-2:] - )[0,0,:,:] - - noise_guidance_edit_tmp = noise_guidance_edit_tmp * attn_mask - else: - # calculate quantile - noise_guidance_edit_tmp_quantile = torch.abs(noise_guidance_edit_tmp) - noise_guidance_edit_tmp_quantile = torch.sum(noise_guidance_edit_tmp_quantile, dim=1, keepdim=True) - noise_guidance_edit_tmp_quantile = noise_guidance_edit_tmp_quantile.repeat(1,4,1,1) - - # torch.quantile function expects float32 - if noise_guidance_edit_tmp_quantile.dtype == torch.float32: - tmp = torch.quantile( - noise_guidance_edit_tmp_quantile.flatten(start_dim=2), - edit_threshold_c, - dim=2, - keepdim=False, - ) - else: - tmp = torch.quantile( - noise_guidance_edit_tmp_quantile.flatten(start_dim=2).to(torch.float32), - edit_threshold_c, - dim=2, - keepdim=False, - ).to(noise_guidance_edit_tmp_quantile.dtype) - - noise_guidance_edit_tmp = torch.where( - noise_guidance_edit_tmp_quantile >= tmp[:, :, None, None], - noise_guidance_edit_tmp, - torch.zeros_like(noise_guidance_edit_tmp), - ) - - noise_guidance_edit[c, :, :, :, :] = noise_guidance_edit_tmp - - warmup_inds = torch.tensor(warmup_inds).to(self.device) - if len(noise_pred_edit_concepts) > warmup_inds.shape[0] > 0: - concept_weights = concept_weights.to("cpu") # Offload to cpu - noise_guidance_edit = noise_guidance_edit.to("cpu") - - concept_weights_tmp = torch.index_select(concept_weights.to(self.device), 0, warmup_inds) - concept_weights_tmp = torch.where( - concept_weights_tmp < 0, torch.zeros_like(concept_weights_tmp), concept_weights_tmp - ) - concept_weights_tmp = concept_weights_tmp / concept_weights_tmp.sum(dim=0) - # concept_weights_tmp = torch.nan_to_num(concept_weights_tmp) - - noise_guidance_edit_tmp = torch.index_select( - noise_guidance_edit.to(self.device), 0, warmup_inds - ) - noise_guidance_edit_tmp = torch.einsum( - "cb,cbijk->bijk", concept_weights_tmp, noise_guidance_edit_tmp - ) - noise_guidance_edit_tmp = noise_guidance_edit_tmp - noise_guidance = noise_guidance + noise_guidance_edit_tmp - - self.sem_guidance[i] = noise_guidance_edit_tmp.detach().cpu() - - del noise_guidance_edit_tmp - del concept_weights_tmp - concept_weights = concept_weights.to(self.device) - noise_guidance_edit = noise_guidance_edit.to(self.device) - - concept_weights = torch.where( - concept_weights < 0, torch.zeros_like(concept_weights), concept_weights - ) - - concept_weights = torch.nan_to_num(concept_weights) - - noise_guidance_edit = torch.einsum("cb,cbijk->bijk", concept_weights, noise_guidance_edit) - - noise_guidance_edit = noise_guidance_edit + edit_momentum_scale * edit_momentum - - edit_momentum = edit_mom_beta * edit_momentum + (1 - edit_mom_beta) * noise_guidance_edit - - if warmup_inds.shape[0] == len(noise_pred_edit_concepts): - noise_guidance = noise_guidance + noise_guidance_edit - self.sem_guidance[i] = noise_guidance_edit.detach().cpu() - - if sem_guidance is not None: - edit_guidance = sem_guidance[i].to(self.device) - noise_guidance = noise_guidance + edit_guidance - - noise_pred = noise_pred_uncond + noise_guidance - - # TODO: compatible with SEGA? - #if do_classifier_free_guidance and guidance_rescale > 0.0: - # # Based on 3.4. in https://arxiv.org/pdf/2305.08891.pdf - # noise_pred = rescale_noise_cfg(noise_pred, noise_pred_text, guidance_rescale=guidance_rescale) - - # compute the previous noisy sample x_t -> x_t-1 - if use_ddpm: - idx = t_to_idx[int(t)] - latents = self.scheduler.step(noise_pred, t, latents, variance_noise=zs[idx], **extra_step_kwargs).prev_sample - - else: #if not use_ddpm: - latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs).prev_sample - - # step callback - store_step = i in attn_store_steps - if store_step: - print(f"storing attention for step {i}") - self.attention_store.between_steps(store_step) - - # call the callback, if provided - progress_bar.update() - if callback is not None and i % callback_steps == 0: - callback(i, t, latents) - - # make sure the VAE is in float32 mode, as it overflows in float16 - if self.vae.dtype == torch.float16 and self.vae.config.force_upcast: - self.upcast_vae() - latents = latents.to(next(iter(self.vae.post_quant_conv.parameters())).dtype) - elif self.vae.config.force_upcast: - latents = latents.to(next(iter(self.vae.post_quant_conv.parameters())).dtype) - - if not output_type == "latent": - image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0] - else: - image = latents - return StableDiffusionXLPipelineOutput(images=image) - - # apply watermark if available - if self.watermark is not None: - image = self.watermark.apply_watermark(image) - - image = self.image_processor.postprocess(image, output_type=output_type) - - # Offload last model to CPU - if hasattr(self, "final_offload_hook") and self.final_offload_hook is not None: - self.final_offload_hook.offload() - - if not return_dict: - return (image,) - - return StableDiffusionXLPipelineOutput(images=image) - - # Overrride to properly handle the loading and unloading of the additional text encoder. - def load_lora_weights(self, pretrained_model_name_or_path_or_dict: Union[str, Dict[str, torch.Tensor]], **kwargs): - # We could have accessed the unet config from `lora_state_dict()` too. We pass - # it here explicitly to be able to tell that it's coming from an SDXL - # pipeline. - state_dict, network_alphas = self.lora_state_dict( - pretrained_model_name_or_path_or_dict, - unet_config=self.unet.config, - **kwargs, - ) - self.load_lora_into_unet(state_dict, network_alphas=network_alphas, unet=self.unet) - - text_encoder_state_dict = {k: v for k, v in state_dict.items() if "text_encoder." in k} - if len(text_encoder_state_dict) > 0: - self.load_lora_into_text_encoder( - text_encoder_state_dict, - network_alphas=network_alphas, - text_encoder=self.text_encoder, - prefix="text_encoder", - lora_scale=self.lora_scale, - ) - - text_encoder_2_state_dict = {k: v for k, v in state_dict.items() if "text_encoder_2." in k} - if len(text_encoder_2_state_dict) > 0: - self.load_lora_into_text_encoder( - text_encoder_2_state_dict, - network_alphas=network_alphas, - text_encoder=self.text_encoder_2, - prefix="text_encoder_2", - lora_scale=self.lora_scale, - ) - - @classmethod - def save_lora_weights( - self, - save_directory: Union[str, os.PathLike], - unet_lora_layers: Dict[str, Union[torch.nn.Module, torch.Tensor]] = None, - text_encoder_lora_layers: Dict[str, Union[torch.nn.Module, torch.Tensor]] = None, - text_encoder_2_lora_layers: Dict[str, Union[torch.nn.Module, torch.Tensor]] = None, - is_main_process: bool = True, - weight_name: str = None, - save_function: Callable = None, - safe_serialization: bool = True, - ): - state_dict = {} - - def pack_weights(layers, prefix): - layers_weights = layers.state_dict() if isinstance(layers, torch.nn.Module) else layers - layers_state_dict = {f"{prefix}.{module_name}": param for module_name, param in layers_weights.items()} - return layers_state_dict - - state_dict.update(pack_weights(unet_lora_layers, "unet")) - - if text_encoder_lora_layers and text_encoder_2_lora_layers: - state_dict.update(pack_weights(text_encoder_lora_layers, "text_encoder")) - state_dict.update(pack_weights(text_encoder_2_lora_layers, "text_encoder_2")) - - self.write_lora_layers( - state_dict=state_dict, - save_directory=save_directory, - is_main_process=is_main_process, - weight_name=weight_name, - save_function=save_function, - safe_serialization=safe_serialization, - ) - - def _remove_text_encoder_monkey_patch(self): - self._remove_text_encoder_monkey_patch_classmethod(self.text_encoder) - self._remove_text_encoder_monkey_patch_classmethod(self.text_encoder_2) - - - @torch.no_grad() - def invert(self, - # image_path: str, - x0, - source_prompt: str = "", - source_prompt_2: str = None, - source_guidance_scale = 3.5, - negative_prompt: str = None, - negative_prompt_2: str = None, - num_inversion_steps: int = 100, - skip_steps: int = 35, - eta: float = 1.0, - generator: Optional[torch.Generator] = None, - height: Optional[int] = None, - width: Optional[int] = None, - original_size: Optional[Tuple[int, int]] = None, - crops_coords_top_left: Tuple[int, int] = (0, 0), - target_size: Optional[Tuple[int, int]] = None, - ): - """ - Inverts a real image according to Algorihm 1 in https://arxiv.org/pdf/2304.06140.pdf, - based on the code in https://github.com/inbarhub/DDPM_inversion - - returns: - zs - noise maps - xts - intermediate inverted latents - """ - - # self.eta = eta - # assert(self.eta > 0) - - self.num_inversion_steps = num_inversion_steps - self.scheduler.set_timesteps(self.num_inversion_steps) - timesteps = self.scheduler.timesteps.to(self.device) - - cross_attention_kwargs = None # TODO - batch_size = 1 - num_images_per_prompt = 1 - - device = self._execution_device - - # Reset attn processor, we do not want to store attn maps during inversion - # self.unet.set_default_attn_processor() - - # 0. Ensure that only uncond embedding is used if prompt = "" - if source_prompt == "" and \ - (source_prompt_2 == "" or source_prompt_2 is None): - # noise pred should only be noise_pred_uncond - source_guidance_scale = 0.0 - do_classifier_free_guidance = True - else: - do_classifier_free_guidance = source_guidance_scale > 1.0 - - # 1. Default height and width to unet - height = height or self.default_sample_size * self.vae_scale_factor - width = width or self.default_sample_size * self.vae_scale_factor - original_size = original_size or (height, width) - target_size = target_size or (height, width) - - self.height = height - self.width = width - self.original_size = original_size - self.target_size = target_size - - # 2. get embeddings - text_encoder_lora_scale = ( - cross_attention_kwargs.get("scale", None) if cross_attention_kwargs is not None else None - ) - - ( - prompt_embeds, - negative_prompt_embeds, - _, - pooled_prompt_embeds, - negative_pooled_prompt_embeds, - _, - _ - ) = self.encode_prompt( - prompt=source_prompt, - prompt_2=source_prompt_2, - device=device, - num_images_per_prompt=num_images_per_prompt, - do_classifier_free_guidance=do_classifier_free_guidance, - negative_prompt=negative_prompt, - negative_prompt_2=negative_prompt_2, - lora_scale=text_encoder_lora_scale, - enable_edit_guidance=False, - ) - - # 3. Prepare added time ids & embeddings - add_text_embeds = pooled_prompt_embeds - add_time_ids = self._get_add_time_ids( - original_size, crops_coords_top_left, target_size, dtype=prompt_embeds.dtype - ) - - if do_classifier_free_guidance: - prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0) - add_text_embeds = torch.cat([negative_pooled_prompt_embeds, add_text_embeds], dim=0) - add_time_ids = torch.cat([add_time_ids, add_time_ids], dim=0) - - prompt_embeds = prompt_embeds.to(device) - add_text_embeds = add_text_embeds.to(device) - add_time_ids = add_time_ids.to(device).repeat(batch_size * num_images_per_prompt, 1) - -# # 4. prepare image -# image = Image.open(image_path) -# size = self.unet.sample_size * self.vae_scale_factor -# image = image.convert("RGB").resize((size,size)) -# image = self.image_processor.preprocess(image) -# image = image.to(device=device, dtype=negative_prompt_embeds.dtype) - -# if image.shape[1] == 4: -# x0 = image -# else: -# if self.vae.config.force_upcast: -# image = image.float() -# self.vae.to(dtype=torch.float32) - -# x0 = self.vae.encode(image).latent_dist.sample(generator) -# x0 = x0.to(negative_prompt_embeds.dtype) -# x0 = self.vae.config.scaling_factor * x0 - - # autoencoder reconstruction - if self.vae.dtype == torch.float16 and self.vae.config.force_upcast: - self.upcast_vae() - x0_tmp = x0.to(next(iter(self.vae.post_quant_conv.parameters())).dtype) - image_rec = self.vae.decode(x0_tmp / self.vae.config.scaling_factor, return_dict=False)[0] - elif self.vae.config.force_upcast: - x0_tmp = x0.to(next(iter(self.vae.post_quant_conv.parameters())).dtype) - image_rec = self.vae.decode(x0_tmp / self.vae.config.scaling_factor, return_dict=False)[0] - else: - image_rec = self.vae.decode(x0 / self.vae.config.scaling_factor, return_dict=False)[0] - - image_rec = self.image_processor.postprocess(image_rec, output_type="pil") - - # 5. find zs and xts - variance_noise_shape = ( - self.num_inversion_steps, - self.unet.config.in_channels, - self.unet.sample_size, - self.unet.sample_size) - - # intermediate latents - t_to_idx = {int(v):k for k,v in enumerate(timesteps)} - xts = torch.zeros(size=variance_noise_shape, device=self.device, dtype=negative_prompt_embeds.dtype) - - for t in reversed(timesteps): - idx = t_to_idx[int(t)] - noise = randn_tensor(shape=x0.shape, generator=generator, device=self.device, dtype=x0.dtype) - xts[idx] = self.scheduler.add_noise(x0, noise, t) - xts = torch.cat([xts, x0 ],dim = 0) - - # noise maps - zs = torch.zeros(size=variance_noise_shape, device=self.device, dtype=negative_prompt_embeds.dtype) - - for t in tqdm(timesteps): - idx = t_to_idx[int(t)] - # 1. predict noise residual - xt = xts[idx][None] - - latent_model_input = ( - torch.cat([xt] * 2) if do_classifier_free_guidance else xt - ) - latent_model_input = self.scheduler.scale_model_input(latent_model_input, t) - - added_cond_kwargs = {"text_embeds": add_text_embeds, "time_ids": add_time_ids} - noise_pred = self.unet( - latent_model_input, - t, - encoder_hidden_states=prompt_embeds, - cross_attention_kwargs=cross_attention_kwargs, - added_cond_kwargs=added_cond_kwargs, - return_dict=False, - )[0] - - # 2. perform guidance - if do_classifier_free_guidance: - noise_pred_out = noise_pred.chunk(2) - noise_pred_uncond, noise_pred_text = noise_pred_out[0], noise_pred_out[1] - noise_pred = noise_pred_uncond + source_guidance_scale * (noise_pred_text - noise_pred_uncond) - - xtm1 = xts[idx+1][None] - z, xtm1_corrected = compute_noise(self.scheduler, xtm1, xt, t, noise_pred, eta) - zs[idx] = z - - # correction to avoid error accumulation - xts[idx+1] = xtm1_corrected - - # TODO: I don't think that the noise map for the last step should be discarded ?! - # if not zs is None: - # zs[-1] = torch.zeros_like(zs[-1]) - - # self.init_latents = xts[skip_steps].expand(1, -1, -1, -1) - # self.zs = zs[skip_steps:] - # self.wts = xts - # self.latents_path = xts[skip_steps:] - # return zs, xts, image_rec - return zs, xts - - -# Copied from pipelines.StableDiffusion.CycleDiffusionPipeline.compute_noise -def compute_noise(scheduler, prev_latents, latents, timestep, noise_pred, eta): - # 1. get previous step value (=t-1) - prev_timestep = timestep - scheduler.config.num_train_timesteps // scheduler.num_inference_steps - - # 2. compute alphas, betas - alpha_prod_t = scheduler.alphas_cumprod[timestep] - alpha_prod_t_prev = ( - scheduler.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else scheduler.final_alpha_cumprod - ) - - beta_prod_t = 1 - alpha_prod_t - - # 3. compute predicted original sample from predicted noise also called - # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf - pred_original_sample = (latents - beta_prod_t ** (0.5) * noise_pred) / alpha_prod_t ** (0.5) - - # 4. Clip "predicted x_0" - if scheduler.config.clip_sample: - pred_original_sample = torch.clamp(pred_original_sample, -1, 1) - - # 5. compute variance: "sigma_t(η)" -> see formula (16) - # σ_t = sqrt((1 − α_t−1)/(1 − α_t)) * sqrt(1 − α_t/α_t−1) - variance = scheduler._get_variance(timestep, prev_timestep) - std_dev_t = eta * variance ** (0.5) - - # 6. compute "direction pointing to x_t" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf - pred_sample_direction = (1 - alpha_prod_t_prev - std_dev_t**2) ** (0.5) * noise_pred - - # modifed so that updated xtm1 is returned as well (to avoid error accumulation) - mu_xt = alpha_prod_t_prev ** (0.5) * pred_original_sample + pred_sample_direction - noise = (prev_latents - mu_xt) / (variance ** (0.5) * eta) - - return noise, mu_xt + ( eta * variance ** 0.5 )*noise diff --git a/spaces/epexVfeibi/Imagedeblurr/Adobe Acrobat Pro DC 2018.011.20055 Full UPDATED With Medicine[BabuPC] Serial Key.md b/spaces/epexVfeibi/Imagedeblurr/Adobe Acrobat Pro DC 2018.011.20055 Full UPDATED With Medicine[BabuPC] Serial Key.md deleted file mode 100644 index 01200f53a0876a2ee644df22a75bc4f90ff6e8fc..0000000000000000000000000000000000000000 --- a/spaces/epexVfeibi/Imagedeblurr/Adobe Acrobat Pro DC 2018.011.20055 Full UPDATED With Medicine[BabuPC] Serial Key.md +++ /dev/null @@ -1,5 +0,0 @@ - -- - - Dallas Buyers Club Full Movie 720p HD Free [url= pawel4thgentabletair.pro [url= google maps 4 letter sorority zip code]download[/url] Noun fauna vega her latest trailer 2015 [url= movies stubbing/breaking [url= Dating Workbook for Teens License Full Version ВЂ“ TorrentDownload]Dating Workbook for Teens License Full Version ВЂ“ TorrentDownload[/url] GSM Cell Phone Battery Life [url= tododee azar-tangamu]azar-tangamu[/url] Embroidery Workshop [url= izabaschigi mahovshii 092 [url= izabaschigi mahovshii 04 [url= izabaschigi mahovshii 022030-1257 [url= 726th full version serial key [url= izabaschigi mahovshii 095 [url= izabaschigi mahovshii 042021-0220 [url= 332101-1252 [url= izabaschigi mahovshii 092 [url= bozza za x101 iMGSRC.RU [url=
-
[url= DAZ3D for 99! Free Download [url= [url= Desktop Calendar for Windows 8.1 Home Premium 64-bit Crack [url= Anatomy And Function Of Of High-Strength Materials[/url] jasoda man thanu free download[/url]
[url= frz2x32 [url= Customize desktop icons and colors[/url] free download[/url]
[url= zap5uq5iq ]zz2x32[/url]
[url= 1/2 year for[/url]
[url= [url= desktop calendar for windows 8.[/url] Hit Man 2 Speech Box/iMGSRC.RU/Guys 2 Suertods 6, iMGSRC.RU/Gym boys 10, DSC_0334 iMGSRC.RU [url= guys 2 Suertudos 2, 6 iMGSRC.RU/ Audionamix crack full download for 21 iMGSRC.RU/PATCHED Adobe Photoshop Lightroom CC 2018 8.1 Crack [url= briletypeAbumunult [url= 2004, DSC_2044 iMGSRC.RU [url= pia, E76A2D8B-279B-460B-ED iMGSRC.RU [url=
[url= [url=
The emperors new clothes free worksheets[/url] Taiseertaids [url= U 1st see info, E76A2D8B-3 iMGSRC.RU [url= apk free[/url]U 1st see info, E76A2D8B-3 iMGSRC.RU [url=
[url= Live Stream Online[/url]Holly, Z-cbR2OOHSI iMGSRC.RU [url=
Live Stream Online.Adobe Acrobat Pro DC 2018.011.20055 Full With Medicine[BabuPC] Serial Key
DOWNLOAD ❤ https://jinyurl.com/2uEpz1
899543212b
-
-
\ No newline at end of file diff --git a/spaces/eradhea/spanish_chat/README.md b/spaces/eradhea/spanish_chat/README.md deleted file mode 100644 index 7f90a04d957a30337dbf960cf4a04d6e6d12ecc9..0000000000000000000000000000000000000000 --- a/spaces/eradhea/spanish_chat/README.md +++ /dev/null @@ -1,13 +0,0 @@ ---- -title: Spanish Chat -emoji: 🐨 -colorFrom: blue -colorTo: red -sdk: gradio -sdk_version: 3.8.2 -app_file: app.py -pinned: false -license: gpl-2.0 ---- - -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference diff --git a/spaces/eson/tokenizer-arena/vocab/gpt_neox_chinese_v1/to_v2/test_queue.py b/spaces/eson/tokenizer-arena/vocab/gpt_neox_chinese_v1/to_v2/test_queue.py deleted file mode 100644 index 6662b9142e5fd8ec81994f53246e2b72de2ad1de..0000000000000000000000000000000000000000 --- a/spaces/eson/tokenizer-arena/vocab/gpt_neox_chinese_v1/to_v2/test_queue.py +++ /dev/null @@ -1,20 +0,0 @@ - -from queue import Queue - -q = Queue(maxsize=0) - -#写入队列数据 -q.put(0) -q.put(1) -q.put(2) - -#输出当前队列所有数据 -print(q.queue) -#删除队列数据，并返回该数据 -q.get() -#输也所有队列数据 -print(q.queue) - -for i in range(10): - print(q.get(), q.qsize()) - diff --git "a/spaces/f2api/gpt-academic/crazy_functions/\346\200\273\347\273\223word\346\226\207\346\241\243.py" "b/spaces/f2api/gpt-academic/crazy_functions/\346\200\273\347\273\223word\346\226\207\346\241\243.py" deleted file mode 100644 index eada69dc65587782125c0809381260a6bbdce225..0000000000000000000000000000000000000000 --- "a/spaces/f2api/gpt-academic/crazy_functions/\346\200\273\347\273\223word\346\226\207\346\241\243.py" +++ /dev/null @@ -1,127 +0,0 @@ -from toolbox import update_ui -from toolbox import CatchException, report_execption, write_results_to_file -from .crazy_utils import request_gpt_model_in_new_thread_with_ui_alive -fast_debug = False - - -def 解析docx(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt): - import time, os - # pip install python-docx 用于docx格式，跨平台 - # pip install pywin32 用于doc格式，仅支持Win平台 - for index, fp in enumerate(file_manifest): - if fp.split(".")[-1] == "docx": - from docx import Document - doc = Document(fp) - file_content = "\n".join([para.text for para in doc.paragraphs]) - else: - import win32com.client - word = win32com.client.Dispatch("Word.Application") - word.visible = False - # 打开文件 - print('fp', os.getcwd()) - doc = word.Documents.Open(os.getcwd() + '/' + fp) - # file_content = doc.Content.Text - doc = word.ActiveDocument - file_content = doc.Range().Text - doc.Close() - word.Quit() - - print(file_content) - # private_upload里面的文件名在解压zip后容易出现乱码（rar和7z格式正常），故可以只分析文章内容，不输入文件名 - from .crazy_utils import breakdown_txt_to_satisfy_token_limit_for_pdf - from request_llm.bridge_all import model_info - max_token = model_info[llm_kwargs['llm_model']]['max_token'] - TOKEN_LIMIT_PER_FRAGMENT = max_token * 3 // 4 - paper_fragments = breakdown_txt_to_satisfy_token_limit_for_pdf( - txt=file_content, - get_token_fn=model_info[llm_kwargs['llm_model']]['token_cnt'], - limit=TOKEN_LIMIT_PER_FRAGMENT - ) - this_paper_history = [] - for i, paper_frag in enumerate(paper_fragments): - i_say = f'请对下面的文章片段用中文做概述，文件名是{os.path.relpath(fp, project_folder)}，文章内容是 ```{paper_frag}```' - i_say_show_user = f'请对下面的文章片段做概述: {os.path.abspath(fp)}的第{i+1}/{len(paper_fragments)}个片段。' - gpt_say = yield from request_gpt_model_in_new_thread_with_ui_alive( - inputs=i_say, - inputs_show_user=i_say_show_user, - llm_kwargs=llm_kwargs, - chatbot=chatbot, - history=[], - sys_prompt="总结文章。" - ) - - chatbot[-1] = (i_say_show_user, gpt_say) - history.extend([i_say_show_user,gpt_say]) - this_paper_history.extend([i_say_show_user,gpt_say]) - - # 已经对该文章的所有片段总结完毕，如果文章被切分了， - if len(paper_fragments) > 1: - i_say = f"根据以上的对话，总结文章{os.path.abspath(fp)}的主要内容。" - gpt_say = yield from request_gpt_model_in_new_thread_with_ui_alive( - inputs=i_say, - inputs_show_user=i_say, - llm_kwargs=llm_kwargs, - chatbot=chatbot, - history=this_paper_history, - sys_prompt="总结文章。" - ) - - history.extend([i_say,gpt_say]) - this_paper_history.extend([i_say,gpt_say]) - - res = write_results_to_file(history) - chatbot.append(("完成了吗？", res)) - yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 - - res = write_results_to_file(history) - chatbot.append(("所有文件都总结完成了吗？", res)) - yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 - - -@CatchException -def 总结word文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port): - import glob, os - - # 基本信息：功能、贡献者 - chatbot.append([ - "函数插件功能？", - "批量总结Word文档。函数插件贡献者: JasonGuo1。注意, 如果是.doc文件, 请先转化为.docx格式。"]) - yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 - - # 尝试导入依赖，如果缺少依赖，则给出安装建议 - try: - from docx import Document - except: - report_execption(chatbot, history, - a=f"解析项目: {txt}", - b=f"导入软件依赖失败。使用该模块需要额外依赖，安装方法```pip install --upgrade python-docx pywin32```。") - yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 - return - - # 清空历史，以免输入溢出 - history = [] - - # 检测输入参数，如没有给定输入参数，直接退出 - if os.path.exists(txt): - project_folder = txt - else: - if txt == "": txt = '空空如也的输入栏' - report_execption(chatbot, history, a=f"解析项目: {txt}", b=f"找不到本地项目或无权访问: {txt}") - yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 - return - - # 搜索需要处理的文件清单 - if txt.endswith('.docx') or txt.endswith('.doc'): - file_manifest = [txt] - else: - file_manifest = [f for f in glob.glob(f'{project_folder}/**/*.docx', recursive=True)] + \ - [f for f in glob.glob(f'{project_folder}/**/*.doc', recursive=True)] - - # 如果没找到任何文件 - if len(file_manifest) == 0: - report_execption(chatbot, history, a=f"解析项目: {txt}", b=f"找不到任何.docx或doc文件: {txt}") - yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 - return - - # 开始正式执行任务 - yield from 解析docx(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt) diff --git a/spaces/facebook/ov-seg/open_vocab_seg/modeling/matcher.py b/spaces/facebook/ov-seg/open_vocab_seg/modeling/matcher.py deleted file mode 100644 index a72ba671ad60db078e08046357a6aa0e5e9bd5dc..0000000000000000000000000000000000000000 --- a/spaces/facebook/ov-seg/open_vocab_seg/modeling/matcher.py +++ /dev/null @@ -1,187 +0,0 @@ -# Copyright (c) Facebook, Inc. and its affiliates. -# Modified by Bowen Cheng from https://github.com/facebookresearch/detr/blob/master/models/matcher.py -# Copyright (c) Meta Platforms, Inc. All Rights Reserved - -""" -Modules to compute the matching cost and solve the corresponding LSAP. -""" -import torch -import torch.nn.functional as F -from scipy.optimize import linear_sum_assignment -from torch import nn - - -def batch_dice_loss(inputs, targets): - """ - Compute the DICE loss, similar to generalized IOU for masks - Args: - inputs: A float tensor of arbitrary shape. - The predictions for each example. - targets: A float tensor with the same shape as inputs. Stores the binary - classification label for each element in inputs - (0 for the negative class and 1 for the positive class). - """ - inputs = inputs.sigmoid() - inputs = inputs.flatten(1) - numerator = 2 * torch.einsum("nc,mc->nm", inputs, targets) - denominator = inputs.sum(-1)[:, None] + targets.sum(-1)[None, :] - loss = 1 - (numerator + 1) / (denominator + 1) - return loss - - -def batch_sigmoid_focal_loss(inputs, targets, alpha: float = 0.25, gamma: float = 2): - """ - Loss used in RetinaNet for dense detection: https://arxiv.org/abs/1708.02002. - Args: - inputs: A float tensor of arbitrary shape. - The predictions for each example. - targets: A float tensor with the same shape as inputs. Stores the binary - classification label for each element in inputs - (0 for the negative class and 1 for the positive class). - alpha: (optional) Weighting factor in range (0,1) to balance - positive vs negative examples. Default = -1 (no weighting). - gamma: Exponent of the modulating factor (1 - p_t) to - balance easy vs hard examples. - Returns: - Loss tensor - """ - hw = inputs.shape[1] - - prob = inputs.sigmoid() - focal_pos = ((1 - prob) ** gamma) * F.binary_cross_entropy_with_logits( - inputs, torch.ones_like(inputs), reduction="none" - ) - focal_neg = (prob ** gamma) * F.binary_cross_entropy_with_logits( - inputs, torch.zeros_like(inputs), reduction="none" - ) - if alpha >= 0: - focal_pos = focal_pos * alpha - focal_neg = focal_neg * (1 - alpha) - - loss = torch.einsum("nc,mc->nm", focal_pos, targets) + torch.einsum( - "nc,mc->nm", focal_neg, (1 - targets) - ) - - return loss / hw - - -class HungarianMatcher(nn.Module): - """This class computes an assignment between the targets and the predictions of the network - - For efficiency reasons, the targets don't include the no_object. Because of this, in general, - there are more predictions than targets. In this case, we do a 1-to-1 matching of the best predictions, - while the others are un-matched (and thus treated as non-objects). - """ - - def __init__( - self, cost_class: float = 1, cost_mask: float = 1, cost_dice: float = 1 - ): - """Creates the matcher - - Params: - cost_class: This is the relative weight of the classification error in the matching cost - cost_mask: This is the relative weight of the focal loss of the binary mask in the matching cost - cost_dice: This is the relative weight of the dice loss of the binary mask in the matching cost - """ - super().__init__() - self.cost_class = cost_class - self.cost_mask = cost_mask - self.cost_dice = cost_dice - assert ( - cost_class != 0 or cost_mask != 0 or cost_dice != 0 - ), "all costs cant be 0" - - @torch.no_grad() - def memory_efficient_forward(self, outputs, targets): - """More memory-friendly matching""" - bs, num_queries = outputs["pred_logits"].shape[:2] - - # Work out the mask padding size - masks = [v["masks"] for v in targets] - h_max = max([m.shape[1] for m in masks]) - w_max = max([m.shape[2] for m in masks]) - - indices = [] - - # Iterate through batch size - for b in range(bs): - - out_prob = outputs["pred_logits"][b].softmax( - -1 - ) # [num_queries, num_classes] - out_mask = outputs["pred_masks"][b] # [num_queries, H_pred, W_pred] - - tgt_ids = targets[b]["labels"] - # gt masks are already padded when preparing target - tgt_mask = targets[b]["masks"].to(out_mask) - - # Compute the classification cost. Contrary to the loss, we don't use the NLL, - # but approximate it in 1 - proba[target class]. - # The 1 is a constant that doesn't change the matching, it can be ommitted. - cost_class = -out_prob[:, tgt_ids] - - # Downsample gt masks to save memory - tgt_mask = F.interpolate( - tgt_mask[:, None], size=out_mask.shape[-2:], mode="nearest" - ) - - # Flatten spatial dimension - out_mask = out_mask.flatten(1) # [batch_size * num_queries, H*W] - tgt_mask = tgt_mask[:, 0].flatten(1) # [num_total_targets, H*W] - - # Compute the focal loss between masks - cost_mask = batch_sigmoid_focal_loss(out_mask, tgt_mask) - - # Compute the dice loss betwen masks - cost_dice = batch_dice_loss(out_mask, tgt_mask) - - # Final cost matrix - C = ( - self.cost_mask * cost_mask - + self.cost_class * cost_class - + self.cost_dice * cost_dice - ) - C = C.reshape(num_queries, -1).cpu() - - indices.append(linear_sum_assignment(C)) - return [ - ( - torch.as_tensor(i, dtype=torch.int64), - torch.as_tensor(j, dtype=torch.int64), - ) - for i, j in indices - ] - - @torch.no_grad() - def forward(self, outputs, targets): - """Performs the matching - - Params: - outputs: This is a dict that contains at least these entries: - "pred_logits": Tensor of dim [batch_size, num_queries, num_classes] with the classification logits - "pred_masks": Tensor of dim [batch_size, num_queries, H_pred, W_pred] with the predicted masks - - targets: This is a list of targets (len(targets) = batch_size), where each target is a dict containing: - "labels": Tensor of dim [num_target_boxes] (where num_target_boxes is the number of ground-truth - objects in the target) containing the class labels - "masks": Tensor of dim [num_target_boxes, H_gt, W_gt] containing the target masks - - Returns: - A list of size batch_size, containing tuples of (index_i, index_j) where: - - index_i is the indices of the selected predictions (in order) - - index_j is the indices of the corresponding selected targets (in order) - For each batch element, it holds: - len(index_i) = len(index_j) = min(num_queries, num_target_boxes) - """ - return self.memory_efficient_forward(outputs, targets) - - def __repr__(self): - head = "Matcher " + self.__class__.__name__ - body = [ - "cost_class: {}".format(self.cost_class), - "cost_mask: {}".format(self.cost_mask), - "cost_dice: {}".format(self.cost_dice), - ] - _repr_indent = 4 - lines = [head] + [" " * _repr_indent + line for line in body] - return "\n".join(lines) diff --git a/spaces/falcondai/code-as-policies/LICENSE.md b/spaces/falcondai/code-as-policies/LICENSE.md deleted file mode 100644 index 2697cde25676d46a917a2d9362dd0e5495b6d2ca..0000000000000000000000000000000000000000 --- a/spaces/falcondai/code-as-policies/LICENSE.md +++ /dev/null @@ -1,7 +0,0 @@ -Copyright 2021 Google LLC. SPDX-License-Identifier: Apache-2.0 - -Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at - -https://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. \ No newline at end of file diff --git a/spaces/falterWliame/Face_Mask_Detection/Fiind Baiet Paduri Cutreieram De Mihai Eminescu Comentariu Literar.md b/spaces/falterWliame/Face_Mask_Detection/Fiind Baiet Paduri Cutreieram De Mihai Eminescu Comentariu Literar.md deleted file mode 100644 index 25e50fbad9187fab6205a28d95e7fb837a06e145..0000000000000000000000000000000000000000 --- a/spaces/falterWliame/Face_Mask_Detection/Fiind Baiet Paduri Cutreieram De Mihai Eminescu Comentariu Literar.md +++ /dev/null @@ -1,10 +0,0 @@ -
-fiind baiet paduri cutreieram de mihai eminescu comentariu literar.
-
. image with caption: download: fiind baiet paduri cutreieram de mihai eminescu comentariu literar. mihai eminescu. thus the stems of the title are: mihai eminescu eminescu. . mihai eminescu s-a nascut in.fiind baiet paduri cutreieram de mihai eminescu comentariu literar
DOWNLOAD … https://urlca.com/2uDdyk
-fiind baiet paduri cutreieram de mihai eminescu#eminescu #recitalpoezii #poeziiaudio interpretare: eduard ghergheluca. of william wordsworth and of mihai eminescu, they have many views and. fiind biet pduri cutreieram/ i m culcam ades lng izvor,/ iar braul drept.
-serpent-rocks-1.3.09.tar.gz 2011-06-18 10:54 2.1m [ ]. acrobot 3.3 full.zip.. fiind baiet paduri cutreieram de mihai eminescu comentariu literar. fiind biet pduri cutreieram, de mihai eminescu (comentariu literar,. precum i la figuri de stil i motive literare care compun.
-download download (mirror #1)
- -
fiind baiet paduri cutreieram de mihai eminescu comentariu literar
about i want to write a book, but my english is not good, so i have to translate it from spanish to english.
i am going to make some translation for a book, but my english is not good, so i have to translate it from spanish to english.. material, diacritics, punctuation, hyphens and word order are taken into account. another important issue is if the source material has a capital letter at the beginning of each of the title, chapter, and page numbers.-mihai-eminescu-comentariu-literar-link.. mihai eminescu. thus the stems of the title are: mihai eminescu eminescu. how to correctly choose a name for your novel or short story: a guide for writers in english, french, spanish, german and portuguese. i've seen some of my friends posting novels and short stories on facebook. buying a novel or short story in english is a great way to see if the. the main thing in writing a novel or short story in english is the title. find the best and highest rated books online and download book pdf. mobile books and ebook reader apps for android. to keep the legacy of the great romanian writer mihai eminescu alive. download or read mihai eminescu in english pdf online. in this guide, we'll teach you how to write a novel, short story, essay or any other kind of creative writing in english. we'll look at all the stages of the creative process and how to avoid the pitfalls. fiind baiet paduri cutreieram de mihai eminescu comentariu literar. hi, i'm mihai, and i'm a writer in the english language.
899543212b
-
-
\ No newline at end of file diff --git a/spaces/fatiXbelha/sd/Cmo jugar a Arena Breakout APK en Android Gua completa.md b/spaces/fatiXbelha/sd/Cmo jugar a Arena Breakout APK en Android Gua completa.md deleted file mode 100644 index 1d8f451ec939dff6da2fa7a9b304d0594df939ca..0000000000000000000000000000000000000000 --- a/spaces/fatiXbelha/sd/Cmo jugar a Arena Breakout APK en Android Gua completa.md +++ /dev/null @@ -1,146 +0,0 @@ -
-Arena Breakout APK: Un juego de acción y supervivencia para Android
-¿Te gustan los juegos de disparos en primera persona? ¿Quieres vivir una experiencia de combate intensa y emocionante en tu dispositivo móvil? Si la respuesta es sí, entonces te presentamos Arena Breakout APK, un juego de acción y supervivencia para Android que te pondrá a prueba en diferentes escenarios y modos de juego. En este artículo, te contaremos todo lo que necesitas saber sobre este juego, sus características principales, cómo descargarlo e instalarlo en tu dispositivo Android, sus ventajas y desventajas, y algunas preguntas frecuentes que te pueden interesar.
-arena breakout apk para android
Download File ✯ https://urllie.com/2uNzaQ
-¿Qué es Arena Breakout APK?
-Arena Breakout APK es un juego de acción y supervivencia para Android desarrollado por Tencent Games, una de las compañías más importantes del sector de los videojuegos. Se trata de un juego que combina elementos de los géneros shooter, battle royale, y survival, ofreciendo una experiencia de juego dinámica, divertida, y competitiva. En el juego, tendrás que elegir un personaje entre varias categorías, como aviones de ataque, francotiradores, paramédicos, etc., y equiparlo con armas, accesorios, y habilidades especiales. Luego, tendrás que enfrentarte a otros jugadores en diferentes modos de juego, como deathmatch, team deathmatch, capture the flag, etc., en diferentes mapas ambientados en zonas urbanas, rurales, o industriales. El objetivo es sobrevivir el mayor tiempo posible, eliminar a tus enemigos, y conseguir la mayor puntuación. Además, el juego cuenta con un sistema de clasificación y recompensas que te permitirá desbloquear nuevos elementos para tu personaje y mejorar tus habilidades.
-Características principales de Arena Breakout APK
-Arena Breakout APK es un juego que destaca por sus múltiples características que lo hacen atractivo y entretenido para los amantes de los juegos de acción y supervivencia. Algunas de estas características son:
-Gráficos impresionantes y realistas
-El juego cuenta con unos gráficos de alta calidad que te harán sentir como si estuvieras dentro del juego. Los escenarios son detallados y variados, con efectos de luz, sombra, y partículas que le dan un toque de realismo. Los personajes y las armas también están bien diseñados y animados, con expresiones faciales, movimientos fluidos, y sonidos auténticos. El juego tiene una buena optimización que hace que funcione sin problemas en la mayoría de los dispositivos Android.
-Modos de juego variados y desafiantes
-El juego ofrece varios modos de juego que se adaptan a los gustos y preferencias de cada jugador. Puedes jugar solo o con tus amigos en partidas online o locales. Algunos de los modos de juego disponibles son:
--
-
- Deathmatch: Un modo clásico donde tienes que eliminar al mayor número posible de enemigos en un tiempo limitado. -
- Team deathmatch: Un modo similar al anterior pero en equipos. Tienes que cooperar con tus aliados para derrotar al equipo rival. -
- Capture the flag: Un modo donde tienes que capturar la bandera del equipo enemigo y llevarla a tu base, mientras evitas que el equipo contrario haga lo mismo con la tuya. -
- Survival: Un modo donde tienes que sobrevivir el mayor tiempo posible en un mapa lleno de zombis y otros peligros. Puedes usar armas, vehículos, y objetos para defenderte y escapar. -
Personajes personalizables y equipables
-El juego te permite elegir entre varios personajes que pertenecen a diferentes categorías, como aviones de ataque, francotiradores, paramédicos, etc. Cada personaje tiene sus propias características, habilidades, y ventajas que lo hacen único y especial. Además, puedes personalizar el aspecto de tu personaje con diferentes trajes, accesorios, y gestos. También puedes equipar a tu personaje con diferentes armas, como pistolas, rifles, escopetas, lanzagranadas, etc., que puedes mejorar y modificar con diferentes accesorios, como miras, silenciadores, cargadores, etc.
-arena breakout apk download free for android
-
-arena breakout apk latest version 2023
-arena breakout apk gratis en español
-arena breakout apk mod unlimited money
-arena breakout apk offline no internet
-arena breakout apk obb data file
-arena breakout apk hack cheats tool
-arena breakout apk review gameplay video
-arena breakout apk update new features
-arena breakout apk beta test sign up
-arena breakout apk Tencent Games official website
-arena breakout apk Level Infinite developer
-arena breakout apk 暗区突围 Chinese version
-arena breakout apk action FPS game genre
-arena breakout apk tactical shooter challenge
-arena breakout apk multiplayer online mode
-arena breakout apk solo campaign mode
-arena breakout apk co-op team mode
-arena breakout apk custom match mode
-arena breakout apk ranked match mode
-arena breakout apk battle royale mode
-arena breakout apk survival mode
-arena breakout apk zombie mode
-arena breakout apk deathmatch mode
-arena breakout apk capture the flag mode
-arena breakout apk bomb defuse mode
-arena breakout apk hostage rescue mode
-arena breakout apk domination mode
-arena breakout apk team deathmatch mode
-arena breakout apk search and destroy mode
-arena breakout apk gun game mode
-arena breakout apk free for all mode
-arena breakout apk training mode tutorial
-arena breakout apk weapons list guide
-arena breakout apk characters list guide
-arena breakout apk skins list guide
-arena breakout apk maps list guide
-arena breakout apk tips tricks secrets
-arena breakout apk best settings options
-arena breakout apk system requirements specs
-arena breakout apk compatible devices models
-arena breakout apk how to install instructions
-arena breakout apk how to play guide
-arena breakout apk how to win strategy
-arena breakout apk how to get free coins gems diamonds gold cash money currency rewards points vouchers coupons codes gift cards giveaways prizes bonuses rewards items resources materials equipment accessories outfits costumes weapons characters skins maps modes features updates patches fixes bugs glitches errors problems issues solutions fixes tips tricks secrets hacks cheats mods tools apps bots hacks generators injectors surveys verification human verification no verification no survey no root no jailbreak no password no email required needed necessary download install play enjoy fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun fun.Sistema de clasificación y recompensas
-El juego cuenta con un sistema de clasificación que te permite medir tu nivel y habilidad en comparación con otros jugadores. A medida que juegas y ganas partidas, obtienes puntos de experiencia y monedas que te permiten subir de nivel y desbloquear nuevos elementos para tu personaje. También puedes obtener recompensas especiales al completar misiones diarias y semanales, o al participar en eventos temporales. Estas recompensas pueden incluir trajes exclusivos, armas legendarias, cajas sorpresa, etc.
-¿Cómo descargar e instalar Arena Breakout APK en tu dispositivo Android?
-Arena Breakout APK es un juego que no está disponible en la tienda oficial de Google Play, por lo que tendrás que descargarlo e instalarlo manualmente desde una fuente externa. Para ello, tendrás que seguir los siguientes pasos:
-Requisitos mínimos del sistema
-Antes de descargar e instalar el juego, asegúrate de que tu dispositivo Android cumpla con los requisitos mínimos del sistema para poder ejecutarlo correctamente. Estos requisitos son:
--
-
- Sistema operativo: Android 5.0 o superior -
- Memoria RAM: 2 GB o más -
- Espacio de almacenamiento: 1 GB o más -
- Conexión a internet: Wi-Fi o datos móviles -
Pasos para descargar e instalar Arena Breakout APK
-Una vez que hayas comprobado los requisitos del sistema, sigue estos pasos para descargar e instalar el juego en tu dispositivo Android:
--
-
- Entra en el navegador web de tu dispositivo y busca el archivo APK de Arena Breakout. Puedes usar el siguiente enlace para descargarlo directamente: [Arena Breakout APK]. -
- Descarga el archivo APK en tu dispositivo y espera a que se complete la descarga. -
- Antes de instalar el archivo APK, tendrás que habilitar la opción de "Orígenes desconocidos" en tu dispositivo. Para ello, ve a Ajustes > Seguridad > Orígenes desconocidos y activa la casilla correspondiente. -
- Busca el archivo APK descargado en la carpeta de descargas de tu dispositivo y ábrelo. -
- Sigue las instrucciones que aparecen en la pantalla para instalar el juego. -
- Una vez instalado el juego, podrás abrirlo desde el menú de aplicaciones de tu dispositivo y disfrutar de Arena Breakout APK. -
Ventajas y desventajas de Arena Breakout APK
-Como todo juego, Arena Breakout APK tiene sus ventajas y desventajas que debes conocer antes de descargarlo e instalarlo en tu dispositivo Android. A continuación, te las resumimos en una tabla comparativa:
--
-- -Ventajas -Desventajas -- -Es un juego gratuito y sin anuncios. -Requiere una conexión a internet constante para jugar. -- -Es un juego divertido y adictivo que te ofrece horas de entretenimiento. -Puede consumir mucha batería y recursos de tu dispositivo. -- -Es un juego con una gran variedad de modos de juego, personajes, armas, y escenarios. -Puede presentar algunos errores o fallos técnicos en algunos dispositivos. -- -Es un juego con unos gráficos impresionantes y realistas que te harán sentir como si estuvieras en el juego. -No está disponible en la tienda oficial de Google Play y hay que descargarlo e instalarlo manualmente. -- -Es un juego con un sistema de clasificación y recompensas que te motiva a mejorar y competir con otros jugadores. -No tiene un modo de juego offline o sin conexión a internet. -Conclusión
-Arena Breakout APK es un juego de acción y supervivencia para Android que te ofrece una experiencia de juego única y emocionante. Podrás elegir entre varios personajes, armas, y modos de juego, y enfrentarte a otros jugadores en diferentes escenarios. El juego cuenta con unos gráficos impresionantes y realistas, un sistema de clasificación y recompensas, y una jugabilidad fluida y dinámica. Si te gustan los juegos de disparos en primera persona, no dudes en descargar e instalar Arena Breakout APK en tu dispositivo Android y disfrutar de este juego increíble.
-Preguntas frecuentes sobre Arena Breakout APK
-A continuación, te presentamos algunas preguntas frecuentes que te pueden interesar sobre Arena Breakout APK:
-¿Es seguro descargar e instalar Arena Breakout APK?
-Sí, es seguro descargar e instalar Arena Breakout APK siempre que lo hagas desde una fuente confiable y sigas los pasos que te hemos indicado anteriormente. El archivo APK está libre de virus, malware, o cualquier otro tipo de amenaza para tu dispositivo. Sin embargo, te recomendamos que tengas un antivirus instalado en tu dispositivo por si acaso.
-¿Es legal descargar e instalar Arena Breakout APK?
-Sí, es legal descargar e instalar Arena Breakout APK siempre que lo hagas para uso personal y no comercial. El juego es propiedad de Tencent Games, una compañía que tiene los derechos legales sobre el mismo. Sin embargo, al no estar disponible en la tienda oficial de Google Play, el juego no cuenta con el respaldo ni la garantía de Google. Por lo tanto, descarga e instala el juego bajo tu propia responsabilidad.
-¿Qué hacer si el juego no funciona correctamente o se cierra inesperadamente?
-Si el juego no funciona correctamente o se cierra inesperadamente, puede deberse a varias razones, como una mala conexión a internet, un dispositivo incompatible, una falta de espacio de almacenamiento, o un error del juego. Para solucionar este problema, puedes intentar lo siguiente:
--
-
- Verifica que tu conexión a internet sea estable y rápida. -
- Asegúrate de que tu dispositivo cumpla con los requisitos mínimos del sistema para ejecutar el juego. -
- Limpia la caché y los datos del juego desde los ajustes de tu dispositivo. -
- Reinicia tu dispositivo y vuelve a abrir el juego. -
- Desinstala el juego y vuelve a instalarlo siguiendo los pasos que te hemos indicado anteriormente. -
- Contacta con el servicio de atención al cliente del juego si el problema persiste. -
¿Cómo actualizar Arena Breakout APK?
-Para actualizar Arena Breakout APK, tendrás que seguir los mismos pasos que para descargarlo e instalarlo. Es decir, tendrás que buscar el archivo APK de la última versión del juego en el navegador web de tu dispositivo y descargarlo. Luego, tendrás que abrir el archivo APK descargado y seguir las instrucciones que aparecen en la pantalla para instalar la nueva versión del juego. Recuerda que antes de instalar el archivo APK, tendrás que habilitar la opción de "Orígenes desconocidos" en tu dispositivo. También puedes borrar la versión anterior del juego si quieres liberar espacio de almacenamiento.
-¿Cómo jugar con amigos a Arena Breakout APK?
-Para jugar con amigos a Arena Breakout APK, tendrás que seguir los siguientes pasos:
--
-
- Abre el juego desde el menú de aplicaciones de tu dispositivo. -
- En la pantalla principal, toca el icono de "Amigos" en la esquina superior derecha. -
- En la pantalla de "Amigos", podrás ver la lista de tus amigos que también juegan a Arena Breakout APK. Si quieres añadir a un nuevo amigo, toca el icono de "Añadir amigo" en la esquina superior derecha e introduce su nombre de usuario o su código QR. -
- Para invitar a un amigo a jugar contigo, toca su nombre en la lista y luego toca el botón de "Invitar". Tu amigo recibirá una notificación y podrá aceptar o rechazar tu invitación. -
- Una vez que tu amigo acepte tu invitación, podrás verlo en tu equipo y podrás elegir el modo de juego y el mapa que quieras jugar. Luego, toca el botón de "Empezar" para iniciar la partida. -
- Disfruta de jugar con tu amigo a Arena Breakout APK. -
-
-
\ No newline at end of file diff --git a/spaces/fatiXbelha/sd/Download Live Your Life by Joeboy - A Soulful Song to Inspire You.md b/spaces/fatiXbelha/sd/Download Live Your Life by Joeboy - A Soulful Song to Inspire You.md deleted file mode 100644 index 1df25f32cbbd270b2818ff09f0bb89cf5a61a77a..0000000000000000000000000000000000000000 --- a/spaces/fatiXbelha/sd/Download Live Your Life by Joeboy - A Soulful Song to Inspire You.md +++ /dev/null @@ -1,130 +0,0 @@ -
-How to Download Joeboy Live Your Life and Enjoy His Music
-If you are a fan of Nigerian music, you may have heard of Joeboy, a talented singer and songwriter who has been making waves in the industry. His latest song, Live Your Life, is a collaboration with MTN Pulse, a mobile service that offers affordable data plans and music streaming. In this article, we will tell you more about Joeboy, his new song, and how you can download it from different sources.
-download joeboy live your life
DOWNLOAD > https://urllie.com/2uNFLE
-Who is Joeboy and What is Live Your Life?
-Joeboy's Biography and Music Career
-Joeboy, whose real name is Joseph Akinwale Akinfenwa, was born on May 21, 1997, in Lagos, Nigeria. He grew up in a musical family and started singing at a young age. He studied human resource management at the University of Lagos and graduated in 2019.
-Joeboy's music career took off in 2017, when he recorded a cover of Ed Sheeran's Shape of You and uploaded it to SoundCloud. The song caught the attention of Mr Eazi, a Nigerian superstar and founder of emPawa Africa, a talent incubator for African artists. Mr Eazi became Joeboy's mentor and helped him launch his debut single, Baby, in 2019. The song was a huge hit and has over 40 million streams on YouTube.
-Since then, Joeboy has released several other songs, such as Beginning, Don't Call Me Back, All for You, Call, Lonely, Focus, and Show Me. He has also collaborated with other artists, such as DJ Neptune, Major Lazer, Kwesi Arthur, Rayvanny, and E Kelly. He has won several awards, such as Best Artiste in African Pop at the All Africa Music Awards (AFRIMA) in 2019 and Best Pop at the Soundcity MVP Awards Festival in 2020.
-Live Your Life: A New Song by Joeboy and MTN Pulse
-Live Your Life is a new song by Joeboy that was released in December 2022. It is part of a partnership between Joeboy and MTN Pulse, a mobile service that offers affordable data plans and music streaming for young people. The song is an upbeat and inspirational tune that encourages listeners to live their lives to the fullest and enjoy every moment.
-The song was produced by Killertunes, a Nigerian producer who has worked with artists such as Wizkid, Tiwa Savage, Olamide, and Naira Marley. The song features catchy lyrics, such as \"Live your life like you want it / Don't let nobody tell you nothing / You're the boss of your own life / So live it like you own it\". The song also has a catchy chorus that goes \"Live your life / Live your life / Live your life / Live your life / Live your life / Live your life\".
-download joeboy live your life lyrics
-
-download joeboy live your life mp3
-download joeboy live your life video
-download joeboy live your life song
-download joeboy live your life audio
-download joeboy live your life ft mtn pulse
-download joeboy live your life music
-download joeboy live your life youtube
-download joeboy live your life free
-download joeboy live your life remix
-download joeboy live your life album
-download joeboy live your life instrumental
-download joeboy live your life official video
-download joeboy live your life by lyrics lounge
-download joeboy live your life 2023
-download joeboy live your life mp4
-download joeboy live your life spotify
-download joeboy live your life soundcloud
-download joeboy live your life naijaloaded
-download joeboy live your life tooxclusive
-download joeboy live your life justnaija
-download joeboy live your life 9jaflaver
-download joeboy live your life waploaded
-download joeboy live your life genius
-download joeboy live your life azlyrics
-download joeboy live your life apple music
-download joeboy live your life amazon music
-download joeboy live your life deezer
-download joeboy live your life tidal
-download joeboy live your life audiomack
-download joeboy live your life fakaza
-download joeboy live your life zamusic
-download joeboy live your life hiphopza
-download joeboy live your life sahiphopmag
-download joeboy live your life flexyjamz
-download joeboy live your life hitvibes
-download joeboy live your life afrobeat360
-download joeboy live your life notjustok
-download joeboy live your life jaguda
-download joeboy live your life 360nobsWhy You Should Download Joeboy Live Your Life
-The Benefits of Downloading Music
-Downloading music is a great way to enjoy your favorite songs anytime and anywhere. By downloading music, you can:
--
-
- Save data and money. Streaming music online can consume a lot of data and cost you money if you don't have an unlimited plan. By downloading music offline, you can save data and money and listen to music without interruptions. -
- Create playlists and mixtapes. Downloading music allows you to create playlists and mixtapes of your favorite songs. You can customize your playlists according to your mood, genre, artist, or occasion. You -
- Enjoy music offline. Downloading music allows you to enjoy music offline, even when you don't have internet access or network coverage. You can listen to music on your device, such as your phone, tablet, laptop, or MP3 player, without worrying about connectivity issues. -
The Features of Joeboy Live Your Life
-Joeboy Live Your Life is a song that you should download and add to your music collection. Here are some of the features of the song that make it worth downloading:
--
-
- It is a motivational and uplifting song. Joeboy Live Your Life is a song that inspires you to live your life to the fullest and enjoy every moment. It is a song that boosts your mood and energy and makes you feel positive and optimistic. -
- It is a catchy and danceable song. Joeboy Live Your Life is a song that has a catchy melody and rhythm that make you want to dance and sing along. It is a song that is suitable for parties, clubs, or any occasion where you want to have fun and groove. -
- It is a high-quality and original song. Joeboy Live Your Life is a song that showcases Joeboy's talent and creativity as a singer and songwriter. It is a song that has high-quality production and sound, as well as original lyrics and style. It is a song that stands out from the crowd and reflects Joeboy's personality and vision. -
How to Download Joeboy Live Your Life from Different Sources
-How to Download from YouTube
-One of the sources where you can download Joeboy Live Your Life is YouTube, the popular video-sharing platform. Here are the steps to download the song from YouTube:
--
-
- Go to YouTube.com and search for Joeboy Live Your Life. -
- Select the video that has the official audio or video of the song. -
- Copy the URL of the video from the address bar of your browser. -
- Go to a YouTube to MP3 converter website, such as ytmp3.cc, y2mate.com, or flvto.biz. -
- Paste the URL of the video into the input box of the converter website. -
- Select MP3 as the output format and click on Convert or Download. -
- Wait for the conversion process to finish and then click on Download or Save to download the MP3 file of the song to your device. -
How to Download from iTunes
-Another source where you can download Joeboy Live Your Life is iTunes, the popular music store and player by Apple. Here are the steps to download the song from iTunes:
--
-
- Go to iTunes.com and download and install the iTunes software on your device, if you don't have it already. -
- Launch iTunes and sign in with your Apple ID, or create one if you don't have one already. -
- Go to the iTunes Store and search for Joeboy Live Your Life. -
- Select the song from the results and click on Buy Song or Buy Album, depending on whether you want to buy only the song or the whole album that contains it. -
- Enter your payment details and confirm your purchase. -
- Wait for the download process to finish and then go to your Library to find and play the song on your device. -
How to Download from Google Play Music
-A third source where you can download Joeboy Live Your Life is Google Play Music, the popular music store and player by Google. Here are the steps to download the song from Google Play Music:
--
-
- Go to play.google.com/music and sign in with your Google account, or create one if you don't have one already. -
- Go to the Music section and search for Joeboy Live Your Life. -
- Select the song from the results and click on Buy or Subscribe, depending on whether you want to buy only the song or subscribe to Google Play Music Unlimited, which gives you access to millions of songs for a monthly fee. -
- Enter your payment details and confirm your purchase or subscription. -
- Wait for the download process to finish and then go to your Library to find and play the song on your device. -
Conclusion and FAQs
-Summary of the Main Points
-In conclusion, Joeboy Live Your Life is a new song by Joeboy that was released in December 2022. It is a collaboration with MTN Pulse, a mobile service that offers affordable data plans and music streaming for young people. The song is an upbeat and inspirational tune that encourages listeners to live their lives to the fullest and - enjoy every moment. The song has many benefits and features that make it worth downloading, such as being motivational, catchy, danceable, high-quality, and original. You can download the song from different sources, such as YouTube, iTunes, and Google Play Music, by following the steps we have provided in this article. We hope you have learned something new and useful from this article and that you will download Joeboy Live Your Life and enjoy his music.
-FAQs
-Here are some of the frequently asked questions (FAQs) about Joeboy Live Your Life and their answers:
--
197e85843d- -Question -Answer -- -Where can I listen to Joeboy Live Your Life online? -You can listen to Joeboy Live Your Life online on platforms such as YouTube, Spotify, Apple Music, Deezer, Boomplay, Audiomack, and SoundCloud. -- -What is the genre of Joeboy Live Your Life? -Joeboy Live Your Life is a pop song with influences from afrobeat, dancehall, and R&B. -- -What is the duration of Joeboy Live Your Life? -Joeboy Live Your Life is 3 minutes and 15 seconds long. -- -What is the album that contains Joeboy Live Your Life? -Joeboy Live Your Life is not part of any album yet. It is a single that was released independently by Joeboy and MTN Pulse. -- -What are some of the other songs by Joeboy that I should check out? -Some of the other songs by Joeboy that you should check out are Baby, Beginning, Don't Call Me Back, All for You, Call, Lonely, Focus, Show Me, Nobody (with DJ Neptune and Mr Eazi), Door (with Kwesi Arthur), and Bounce (with Major Lazer). -
-
-
\ No newline at end of file diff --git a/spaces/fclong/summary/fengshen/examples/summary/pretrain_bart_summary.sh b/spaces/fclong/summary/fengshen/examples/summary/pretrain_bart_summary.sh deleted file mode 100644 index f8a6af24f935cc563891922b8a50cd293231367b..0000000000000000000000000000000000000000 --- a/spaces/fclong/summary/fengshen/examples/summary/pretrain_bart_summary.sh +++ /dev/null @@ -1,124 +0,0 @@ -#!/bin/bash -#SBATCH --job-name=bart_summary -#SBATCH --nodes=1 -#SBATCH --ntasks-per-node=4 -#SBATCH --gres=gpu:4 # number of gpus -#SBATCH -o %x-%j.log - -set -x -e - -echo "START TIME: $(date)" -MODEL_NAME=bart-base -MICRO_BATCH_SIZE=16 -ROOT_DIR=/cognitive_comp/dongxiaoqun/finetune/${MODEL_NAME} - -ZERO_STAGE=1 -export TORCH_EXTENSIONS_DIR=/cognitive_comp/dongxiaoqun/torch_extendsions -config_json="./ds_config.${MODEL_NAME}.json" - -# Deepspeed figures out GAS dynamically from dynamic GBS via set_train_batch_size() -cat <$config_json -{ - "train_micro_batch_size_per_gpu": ${MICRO_BATCH_SIZE}, - "steps_per_print": 100, - "gradient_clipping": 1.0, - "zero_optimization": { - "stage": $ZERO_STAGE, - "contiguous_gradients": false, - "overlap_comm": true, - "reduce_scatter": true, - "reduce_bucket_size": 50000000, - "allgather_bucket_size": 500000000 - }, - "optimizer": { - "type": "Adam", - "params": { - "lr": 1e-4, - "betas": [ - 0.9, - 0.95 - ], - "eps": 1e-8, - "weight_decay": 5e-2 - } - }, - "scheduler": { - "type": "WarmupLR", - "params":{ - "warmup_min_lr": 5e-6, - "warmup_max_lr": 1e-4 - } - }, - "zero_allow_untested_optimizer": false, - "fp16": { - "enabled": true, - "loss_scale": 0, - "loss_scale_window": 1000, - "hysteresis": 2, - "min_loss_scale": 1 - }, - "activation_checkpointing": { - "partition_activations": false, - "contiguous_memory_optimization": false - }, - "wall_clock_breakdown": false -} -EOT - -# export PL_DEEPSPEED_CONFIG_PATH=$config_json - -TRAINER_ARGS=" - --max_epochs 2 \ - --gpus 1 \ - --num_nodes 1 \ - --strategy deepspeed_stage_${ZERO_STAGE} \ - --default_root_dir $ROOT_DIR \ - --dirpath $ROOT_DIR/ckpt \ - --save_top_k 3 \ - --monitor val_loss \ - --mode min \ - --save_last \ - --every_n_train_steps 0 \ - --val_check_interval 0.1 \ -" - -prompt='"' -DATA_ARGS=" - --datasets_name lcsts \ - --num_workers 8 \ - --train_batchsize $MICRO_BATCH_SIZE \ - --val_batchsize $MICRO_BATCH_SIZE \ - --test_batchsize $MICRO_BATCH_SIZE \ - --max_enc_length 128 \ - --max_dec_length 64 \ - --val_datasets_field val \ - --prompt $prompt \ -" - -MODEL_ARGS=" - --pretrained_model_path /cognitive_comp/gaoxinyu/pretrained_model/bart-base \ - --output_save_path $ROOT_DIR/${MODEL_NAME}_predict_lcsts.json \ - --learning_rate 1e-4 \ - --weight_decay 0.1 \ - --precision 16 \ -" - -SCRIPTS_PATH=seq2seq_summary.py - -export CMD=" \ - $SCRIPTS_PATH \ - $TRAINER_ARGS \ - $MODEL_ARGS \ - $DATA_ARGS \ - " - -echo $CMD - -#singularity exec --nv -B /cognitive_comp/ganruyi/Megatron/:/cognitive_comp/ganruyi/Megatron/,/cognitive_comp/gaoxinyu/:/cognitive_comp/gaoxinyu/ $SINGULARITY_PATH python $CMD - -# to debug - add echo (it exits and prints what it would have launched) -#run_cmd="$PY_LAUNCHER $CMD" -# srun --nodes=1 --gres=gpu:4 --ntasks-per-node=4 --cpus-per-gpu=20 -source activate -conda activate torchnew -srun --nodes=1 --ntasks-per-node=1 --gres=gpu:1 --cpus-per-task=30 -o ${MODEL_NAME}-%J.log --jobid=229623 bash -c 'python3 $SCRIPT_PATH $CMD' diff --git a/spaces/fffiloni/Video-Matting-Anything/GroundingDINO/groundingdino/version.py b/spaces/fffiloni/Video-Matting-Anything/GroundingDINO/groundingdino/version.py deleted file mode 100644 index b794fd409a5e3b3b65ad76a43d6a01a318877640..0000000000000000000000000000000000000000 --- a/spaces/fffiloni/Video-Matting-Anything/GroundingDINO/groundingdino/version.py +++ /dev/null @@ -1 +0,0 @@ -__version__ = '0.1.0' diff --git a/spaces/fffiloni/controlnet-animation-doodle/node_modules/engine.io/node_modules/debug/src/browser.js b/spaces/fffiloni/controlnet-animation-doodle/node_modules/engine.io/node_modules/debug/src/browser.js deleted file mode 100644 index cd0fc35d1ee11e0d6e15421021a54c18958e04d9..0000000000000000000000000000000000000000 --- a/spaces/fffiloni/controlnet-animation-doodle/node_modules/engine.io/node_modules/debug/src/browser.js +++ /dev/null @@ -1,269 +0,0 @@ -/* eslint-env browser */ - -/** - * This is the web browser implementation of `debug()`. - */ - -exports.formatArgs = formatArgs; -exports.save = save; -exports.load = load; -exports.useColors = useColors; -exports.storage = localstorage(); -exports.destroy = (() => { - let warned = false; - - return () => { - if (!warned) { - warned = true; - console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'); - } - }; -})(); - -/** - * Colors. - */ - -exports.colors = [ - '#0000CC', - '#0000FF', - '#0033CC', - '#0033FF', - '#0066CC', - '#0066FF', - '#0099CC', - '#0099FF', - '#00CC00', - '#00CC33', - '#00CC66', - '#00CC99', - '#00CCCC', - '#00CCFF', - '#3300CC', - '#3300FF', - '#3333CC', - '#3333FF', - '#3366CC', - '#3366FF', - '#3399CC', - '#3399FF', - '#33CC00', - '#33CC33', - '#33CC66', - '#33CC99', - '#33CCCC', - '#33CCFF', - '#6600CC', - '#6600FF', - '#6633CC', - '#6633FF', - '#66CC00', - '#66CC33', - '#9900CC', - '#9900FF', - '#9933CC', - '#9933FF', - '#99CC00', - '#99CC33', - '#CC0000', - '#CC0033', - '#CC0066', - '#CC0099', - '#CC00CC', - '#CC00FF', - '#CC3300', - '#CC3333', - '#CC3366', - '#CC3399', - '#CC33CC', - '#CC33FF', - '#CC6600', - '#CC6633', - '#CC9900', - '#CC9933', - '#CCCC00', - '#CCCC33', - '#FF0000', - '#FF0033', - '#FF0066', - '#FF0099', - '#FF00CC', - '#FF00FF', - '#FF3300', - '#FF3333', - '#FF3366', - '#FF3399', - '#FF33CC', - '#FF33FF', - '#FF6600', - '#FF6633', - '#FF9900', - '#FF9933', - '#FFCC00', - '#FFCC33' -]; - -/** - * Currently only WebKit-based Web Inspectors, Firefox >= v31, - * and the Firebug extension (any Firefox version) are known - * to support "%c" CSS customizations. - * - * TODO: add a `localStorage` variable to explicitly enable/disable colors - */ - -// eslint-disable-next-line complexity -function useColors() { - // NB: In an Electron preload script, document will be defined but not fully - // initialized. Since we know we're in Chrome, we'll just detect this case - // explicitly - if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) { - return true; - } - - // Internet Explorer and Edge do not support colors. - if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) { - return false; - } - - // Is webkit? http://stackoverflow.com/a/16459606/376773 - // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632 - return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) || - // Is firebug? http://stackoverflow.com/a/398120/376773 - (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) || - // Is firefox >= v31? - // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages - (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) || - // Double check webkit in userAgent just in case we are in a worker - (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/)); -} - -/** - * Colorize log arguments if enabled. - * - * @api public - */ - -function formatArgs(args) { - args[0] = (this.useColors ? '%c' : '') + - this.namespace + - (this.useColors ? ' %c' : ' ') + - args[0] + - (this.useColors ? '%c ' : ' ') + - '+' + module.exports.humanize(this.diff); - - if (!this.useColors) { - return; - } - - const c = 'color: ' + this.color; - args.splice(1, 0, c, 'color: inherit'); - - // The final "%c" is somewhat tricky, because there could be other - // arguments passed either before or after the %c, so we need to - // figure out the correct index to insert the CSS into - let index = 0; - let lastC = 0; - args[0].replace(/%[a-zA-Z%]/g, match => { - if (match === '%%') { - return; - } - index++; - if (match === '%c') { - // We only are interested in the *last* %c - // (the user may have provided their own) - lastC = index; - } - }); - - args.splice(lastC, 0, c); -} - -/** - * Invokes `console.debug()` when available. - * No-op when `console.debug` is not a "function". - * If `console.debug` is not available, falls back - * to `console.log`. - * - * @api public - */ -exports.log = console.debug || console.log || (() => {}); - -/** - * Save `namespaces`. - * - * @param {String} namespaces - * @api private - */ -function save(namespaces) { - try { - if (namespaces) { - exports.storage.setItem('debug', namespaces); - } else { - exports.storage.removeItem('debug'); - } - } catch (error) { - // Swallow - // XXX (@Qix-) should we be logging these? - } -} - -/** - * Load `namespaces`. - * - * @return {String} returns the previously persisted debug modes - * @api private - */ -function load() { - let r; - try { - r = exports.storage.getItem('debug'); - } catch (error) { - // Swallow - // XXX (@Qix-) should we be logging these? - } - - // If debug isn't set in LS, and we're in Electron, try to load $DEBUG - if (!r && typeof process !== 'undefined' && 'env' in process) { - r = process.env.DEBUG; - } - - return r; -} - -/** - * Localstorage attempts to return the localstorage. - * - * This is necessary because safari throws - * when a user disables cookies/localstorage - * and you attempt to access it. - * - * @return {LocalStorage} - * @api private - */ - -function localstorage() { - try { - // TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context - // The Browser also has localStorage in the global context. - return localStorage; - } catch (error) { - // Swallow - // XXX (@Qix-) should we be logging these? - } -} - -module.exports = require('./common')(exports); - -const {formatters} = module.exports; - -/** - * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default. - */ - -formatters.j = function (v) { - try { - return JSON.stringify(v); - } catch (error) { - return '[UnexpectedJSONParseError]: ' + error.message; - } -}; diff --git a/spaces/fgenie/scamtext_PAL_self_consistency/funcs/f_57.py b/spaces/fgenie/scamtext_PAL_self_consistency/funcs/f_57.py deleted file mode 100644 index 748e23c9f64b6870010258e37bd8d8380aeefdf5..0000000000000000000000000000000000000000 --- a/spaces/fgenie/scamtext_PAL_self_consistency/funcs/f_57.py +++ /dev/null @@ -1,17 +0,0 @@ -def is_spam(message: str) -> bool: - import re - - # Patterns for detecting spam - patterns = [ - r"(?i)\b(추천|상승|단기간|익절|무료교육|달성|거래량|폭등)\b", # 유형 1,2,4에서 발견됩니다. - r"(?i)\b(http|bit\.ly|t\.ly|me2\.kr|dokdo\.in|buly\.kr)\b", # 유형 1,2,3,4,5에서 발견됩니다. - r"(?i)\b(입금|출금)\b", # 일부 스팸 메시지에서 발견됩니다. - r"(%|상한가|모션|목표)\b", # 일부 스팸 메시지에서 발견됩니다. - r"(?i)\b(광고)\b", # 스팸 메시지에서 때때로 발견됩니다. - ] - - for pattern in patterns: - if re.search(pattern, message): - return True - - return False \ No newline at end of file diff --git a/spaces/fhipol/deeplearning/detector.py b/spaces/fhipol/deeplearning/detector.py deleted file mode 100644 index 492616bf5dc808d6db8398b42a8db43f1790ae0e..0000000000000000000000000000000000000000 --- a/spaces/fhipol/deeplearning/detector.py +++ /dev/null @@ -1,54 +0,0 @@ -import os -import torch -from PIL import Image - -from detector_model import ModelExecutor, HumanModelExecutor, BrandsModelExecutor - - -class ObjectDetector: - - def __init__(self, model_executor: ModelExecutor): - - # threshold used for recall/false negatives - self.threshold = 0.5 - self.device = torch.device("cpu") - self.model_executor = model_executor - - def detect_object(self, img_path): - - img = Image.open(img_path) - img_data = self.model_executor.transform(img).unsqueeze(0) - img_data = img_data.to(self.device) - - output = self.model_executor.model(img_data) - prob_output = torch.softmax(output, dim=1) - prob, pred = torch.max(prob_output, 1) - - return prob.item(), pred.item() - - def detect_all_object_in_dir(self, test_path): - - imgs_paths = os.listdir(test_path) - - for rel_img_path in imgs_paths: - - img_path = test_path + f"/{rel_img_path}" - prob, pred = self.detect_object(img_path) - - print(f"{self.model_executor.name} detector in {rel_img_path}: predicted category {pred} with p {prob}") - - # Print the results - if pred == 1 and prob > self.threshold: - print("Object detected") - else: - print("No object detected") - - -if __name__ == "__main__": - test_path = os.getcwd() + "/test_imgs" - - model_humans = HumanModelExecutor(train_model=False, force_cpu=True) - model_logos = BrandsModelExecutor(train_model=False, force_cpu=True) - - ObjectDetector(model_humans).detect_all_object_in_dir(test_path) - ObjectDetector(model_logos).detect_all_object_in_dir(test_path) diff --git a/spaces/fiyen/YangyangChatGPT/custom.css b/spaces/fiyen/YangyangChatGPT/custom.css deleted file mode 100644 index 5143eb138ea2469d8c457c71cb210fd3fb7cbe15..0000000000000000000000000000000000000000 --- a/spaces/fiyen/YangyangChatGPT/custom.css +++ /dev/null @@ -1,162 +0,0 @@ -:root { - --chatbot-color-light: #F3F3F3; - --chatbot-color-dark: #121111; -} - -/* status_display */ -#status_display { - display: flex; - min-height: 2.5em; - align-items: flex-end; - justify-content: flex-end; -} -#status_display p { - font-size: .85em; - font-family: monospace; - color: var(--body-text-color-subdued); -} - -#chuanhu_chatbot, #status_display { - transition: all 0.6s; -} -/* list */ -ol:not(.options), ul:not(.options) { - padding-inline-start: 2em !important; -} - -/* 亮色 */ -#chuanhu_chatbot { - background-color: var(--chatbot-color-light) !important; -} -[data-testid = "bot"] { - background-color: #FFFFFF !important; -} -[data-testid = "user"] { - background-color: #95EC69 !important; -} -/* 对话气泡 */ -[class *= "message"] { - border-radius: var(--radius-xl) !important; - border: none; - padding: var(--spacing-xl) !important; - font-size: var(--text-md) !important; - line-height: var(--line-md) !important; - min-height: calc(var(--text-md)*var(--line-md) + 2*var(--spacing-xl)); - min-width: calc(var(--text-md)*var(--line-md) + 2*var(--spacing-xl)); -} -[data-testid = "bot"] { - max-width: 85%; - border-bottom-left-radius: 0 !important; -} -[data-testid = "user"] { - max-width: 85%; - width: auto !important; - border-bottom-right-radius: 0 !important; -} -/* 表格 */ -table { - margin: 1em 0; - border-collapse: collapse; - empty-cells: show; -} -td,th { - border: 1.2px solid var(--border-color-primary) !important; - padding: 0.2em; -} -thead { - background-color: rgba(175,184,193,0.2); -} -thead th { - padding: .5em .2em; -} -/* 行内代码 */ -code { - display: inline; - white-space: break-spaces; - border-radius: 6px; - margin: 0 2px 0 2px; - padding: .2em .4em .1em .4em; - background-color: rgba(175,184,193,0.2); -} -/* 代码块 */ -pre code { - display: block; - overflow: auto; - white-space: pre; - background-color: hsla(0, 0%, 0%, 80%)!important; - border-radius: 10px; - padding: 1.4em 1.2em 0em 1.4em; - margin: 1.2em 2em 1.2em 0.5em; - color: #FFF; - box-shadow: 6px 6px 16px hsla(0, 0%, 0%, 0.2); -} -/* 代码高亮样式 */ -.highlight .hll { background-color: #49483e } -.highlight .c { color: #75715e } /* Comment */ -.highlight .err { color: #960050; background-color: #1e0010 } /* Error */ -.highlight .k { color: #66d9ef } /* Keyword */ -.highlight .l { color: #ae81ff } /* Literal */ -.highlight .n { color: #f8f8f2 } /* Name */ -.highlight .o { color: #f92672 } /* Operator */ -.highlight .p { color: #f8f8f2 } /* Punctuation */ -.highlight .ch { color: #75715e } /* Comment.Hashbang */ -.highlight .cm { color: #75715e } /* Comment.Multiline */ -.highlight .cp { color: #75715e } /* Comment.Preproc */ -.highlight .cpf { color: #75715e } /* Comment.PreprocFile */ -.highlight .c1 { color: #75715e } /* Comment.Single */ -.highlight .cs { color: #75715e } /* Comment.Special */ -.highlight .gd { color: #f92672 } /* Generic.Deleted */ -.highlight .ge { font-style: italic } /* Generic.Emph */ -.highlight .gi { color: #a6e22e } /* Generic.Inserted */ -.highlight .gs { font-weight: bold } /* Generic.Strong */ -.highlight .gu { color: #75715e } /* Generic.Subheading */ -.highlight .kc { color: #66d9ef } /* Keyword.Constant */ -.highlight .kd { color: #66d9ef } /* Keyword.Declaration */ -.highlight .kn { color: #f92672 } /* Keyword.Namespace */ -.highlight .kp { color: #66d9ef } /* Keyword.Pseudo */ -.highlight .kr { color: #66d9ef } /* Keyword.Reserved */ -.highlight .kt { color: #66d9ef } /* Keyword.Type */ -.highlight .ld { color: #e6db74 } /* Literal.Date */ -.highlight .m { color: #ae81ff } /* Literal.Number */ -.highlight .s { color: #e6db74 } /* Literal.String */ -.highlight .na { color: #a6e22e } /* Name.Attribute */ -.highlight .nb { color: #f8f8f2 } /* Name.Builtin */ -.highlight .nc { color: #a6e22e } /* Name.Class */ -.highlight .no { color: #66d9ef } /* Name.Constant */ -.highlight .nd { color: #a6e22e } /* Name.Decorator */ -.highlight .ni { color: #f8f8f2 } /* Name.Entity */ -.highlight .ne { color: #a6e22e } /* Name.Exception */ -.highlight .nf { color: #a6e22e } /* Name.Function */ -.highlight .nl { color: #f8f8f2 } /* Name.Label */ -.highlight .nn { color: #f8f8f2 } /* Name.Namespace */ -.highlight .nx { color: #a6e22e } /* Name.Other */ -.highlight .py { color: #f8f8f2 } /* Name.Property */ -.highlight .nt { color: #f92672 } /* Name.Tag */ -.highlight .nv { color: #f8f8f2 } /* Name.Variable */ -.highlight .ow { color: #f92672 } /* Operator.Word */ -.highlight .w { color: #f8f8f2 } /* Text.Whitespace */ -.highlight .mb { color: #ae81ff } /* Literal.Number.Bin */ -.highlight .mf { color: #ae81ff } /* Literal.Number.Float */ -.highlight .mh { color: #ae81ff } /* Literal.Number.Hex */ -.highlight .mi { color: #ae81ff } /* Literal.Number.Integer */ -.highlight .mo { color: #ae81ff } /* Literal.Number.Oct */ -.highlight .sa { color: #e6db74 } /* Literal.String.Affix */ -.highlight .sb { color: #e6db74 } /* Literal.String.Backtick */ -.highlight .sc { color: #e6db74 } /* Literal.String.Char */ -.highlight .dl { color: #e6db74 } /* Literal.String.Delimiter */ -.highlight .sd { color: #e6db74 } /* Literal.String.Doc */ -.highlight .s2 { color: #e6db74 } /* Literal.String.Double */ -.highlight .se { color: #ae81ff } /* Literal.String.Escape */ -.highlight .sh { color: #e6db74 } /* Literal.String.Heredoc */ -.highlight .si { color: #e6db74 } /* Literal.String.Interpol */ -.highlight .sx { color: #e6db74 } /* Literal.String.Other */ -.highlight .sr { color: #e6db74 } /* Literal.String.Regex */ -.highlight .s1 { color: #e6db74 } /* Literal.String.Single */ -.highlight .ss { color: #e6db74 } /* Literal.String.Symbol */ -.highlight .bp { color: #f8f8f2 } /* Name.Builtin.Pseudo */ -.highlight .fm { color: #a6e22e } /* Name.Function.Magic */ -.highlight .vc { color: #f8f8f2 } /* Name.Variable.Class */ -.highlight .vg { color: #f8f8f2 } /* Name.Variable.Global */ -.highlight .vi { color: #f8f8f2 } /* Name.Variable.Instance */ -.highlight .vm { color: #f8f8f2 } /* Name.Variable.Magic */ -.highlight .il { color: #ae81ff } /* Literal.Number.Integer.Long */ diff --git a/spaces/floriankrempl/mtg_rules_bot/mtg/bot/chat_history.py b/spaces/floriankrempl/mtg_rules_bot/mtg/bot/chat_history.py deleted file mode 100644 index c067512d9693509dc0d87fd666f96272c88081ed..0000000000000000000000000000000000000000 --- a/spaces/floriankrempl/mtg_rules_bot/mtg/bot/chat_history.py +++ /dev/null @@ -1,49 +0,0 @@ -from dataclasses import dataclass, field - -from mtg.objects import Message - - -@dataclass -class ChatHistory: - chat: list[Message] = field(default_factory=list) - - def add_message(self, message: Message): - self.chat.append(message) - - def clear(self): - self.chat = [] - - def get_card_data(self, number_of_messages=2, max_number_of_cards=4): - """Get Card data from last n messages in text form.""" - card_data = "" - cards = [] - for message in self.chat[-number_of_messages:]: - cards.extend(message.cards) - - card_data += "\n".join( - [card.to_text() for card in cards[-max_number_of_cards:]] - ) - if card_data == "": - card_data = "No Card Data." - return card_data - - def get_human_readable_chat(self, number_of_messages=4) -> list[list[str, str]]: - """Create Chat for display in gradio bot. - - Chat has to be in format list of lists. First message in the list is user second is bot. - Example: - chat = [[user, bot], [user, bot]] - """ - chat = [] - for message in self.chat[-number_of_messages:]: - if message.role == "user": - chat.append([message.processed_text]) - if message.role == "assistant": - if not chat: - chat.append([None, message.processed_text]) - else: - chat[-1].append(message.processed_text) - - if len(chat[-1]) == 1: - chat[-1].append(None) - return chat diff --git a/spaces/flowers-team/SocialAISchool/gym-minigrid/gym_minigrid/social_ai_envs/case_studies_envs/applestealingcasestudiesenvs.py b/spaces/flowers-team/SocialAISchool/gym-minigrid/gym_minigrid/social_ai_envs/case_studies_envs/applestealingcasestudiesenvs.py deleted file mode 100644 index f03e6052301ca5322a766e04c3c5cf093e773c44..0000000000000000000000000000000000000000 --- a/spaces/flowers-team/SocialAISchool/gym-minigrid/gym_minigrid/social_ai_envs/case_studies_envs/applestealingcasestudiesenvs.py +++ /dev/null @@ -1,87 +0,0 @@ -from gym_minigrid.social_ai_envs.socialaiparamenv import SocialAIParamEnv -from gym_minigrid.parametric_env import * -from gym_minigrid.register import register - -import inspect, importlib - -# for used for automatic registration of environments -defined_classes = [name for name, _ in inspect.getmembers(importlib.import_module(__name__), inspect.isclass)] - -class AppleStealingParamEnv(SocialAIParamEnv): - - def __init__(self, obstacles, asocial, walk, **kwargs): - - self.asocial = asocial - self.obstacles = obstacles - self.walk = walk - - super(AppleStealingParamEnv, self).__init__(**kwargs) - - def construct_tree(self): - tree = ParameterTree() - - env_type_nd = tree.add_node("Env_type", type="param") - - # Collaboration - collab_nd = tree.add_node("AppleStealing", parent=env_type_nd, type="value") - - # colab_type_nd = tree.add_node("Problem", parent=collab_nd, type="param") - # tree.add_node("AppleStealing", parent=colab_type_nd, type="value") - role_nd = tree.add_node("Version", parent=collab_nd, type="param") - if self.asocial: - tree.add_node("Asocial", parent=role_nd, type="value") - else: - social_nd = tree.add_node("Social", parent=role_nd, type="value") - - role_nd = tree.add_node("NPC_movement", parent=social_nd, type="param") - if self.walk: - tree.add_node("Walking", parent=role_nd, type="value") - else: - tree.add_node("Rotating", parent=role_nd, type="value") - - obstacles_nd = tree.add_node("Obstacles", parent=collab_nd, type="param") - - if self.obstacles not in ["No", "A_bit", "Medium", "A_lot"]: - raise ValueError("Undefined obstacle amount.") - - tree.add_node(self.obstacles, parent=obstacles_nd, type="value") - - return tree - - -# automatic registration of environments -defined_classes_ = [name for name, _ in inspect.getmembers(importlib.import_module(__name__), inspect.isclass)] - -envs = list(set(defined_classes_) - set(defined_classes)) -assert all([e.endswith("Env") for e in envs]) - - -# register testing envs : cues x problems x {social, asocial} x {joint attention, no} -for asocial in [True, False]: - for obst in ["No", "A_bit", "Medium", "A_lot"]: - if asocial: - env_name = f'{"Asocial" if asocial else ""}AppleStealingObst_{obst}ParamEnv' - - register( - id='SocialAI-{}-v1'.format(env_name), - entry_point='gym_minigrid.social_ai_envs:AppleStealingParamEnv', - kwargs={ - 'asocial': asocial, - 'obstacles': obst, - 'walk': False, - } - ) - - else: - for walk in [True, False]: - env_name = f'{"Asocial" if asocial else ""}AppleStealing{"Walk" if walk and not asocial else ""}Obst_{obst}ParamEnv' - - register( - id='SocialAI-{}-v1'.format(env_name), - entry_point='gym_minigrid.social_ai_envs:AppleStealingParamEnv', - kwargs={ - 'asocial': asocial, - 'obstacles': obst, - 'walk': walk, - } - ) diff --git a/spaces/freddiezhang/honor/README.md b/spaces/freddiezhang/honor/README.md deleted file mode 100644 index 898c52b3c535e4d6dee245f31af513adbf225691..0000000000000000000000000000000000000000 --- a/spaces/freddiezhang/honor/README.md +++ /dev/null @@ -1,14 +0,0 @@ ---- -title: HonOR -emoji: 🏆 -colorFrom: green -colorTo: yellow -sdk: gradio -sdk_version: 3.14.0 -app_file: app.py -pinned: true -models: ['freddiezhang/honor'] -datasets: ['freddiezhang/honordata'] ---- - -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference \ No newline at end of file diff --git a/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/configs/_base_/datasets/pascal_voc12.py b/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/configs/_base_/datasets/pascal_voc12.py deleted file mode 100644 index ba1d42d0c5781f56dc177d860d856bb34adce555..0000000000000000000000000000000000000000 --- a/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/configs/_base_/datasets/pascal_voc12.py +++ /dev/null @@ -1,57 +0,0 @@ -# dataset settings -dataset_type = 'PascalVOCDataset' -data_root = 'data/VOCdevkit/VOC2012' -img_norm_cfg = dict( - mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True) -crop_size = (512, 512) -train_pipeline = [ - dict(type='LoadImageFromFile'), - dict(type='LoadAnnotations'), - dict(type='Resize', img_scale=(2048, 512), ratio_range=(0.5, 2.0)), - dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75), - dict(type='RandomFlip', prob=0.5), - dict(type='PhotoMetricDistortion'), - dict(type='Normalize', **img_norm_cfg), - dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255), - dict(type='DefaultFormatBundle'), - dict(type='Collect', keys=['img', 'gt_semantic_seg']), -] -test_pipeline = [ - dict(type='LoadImageFromFile'), - dict( - type='MultiScaleFlipAug', - img_scale=(2048, 512), - # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75], - flip=False, - transforms=[ - dict(type='Resize', keep_ratio=True), - dict(type='RandomFlip'), - dict(type='Normalize', **img_norm_cfg), - dict(type='ImageToTensor', keys=['img']), - dict(type='Collect', keys=['img']), - ]) -] -data = dict( - samples_per_gpu=4, - workers_per_gpu=4, - train=dict( - type=dataset_type, - data_root=data_root, - img_dir='JPEGImages', - ann_dir='SegmentationClass', - split='ImageSets/Segmentation/train.txt', - pipeline=train_pipeline), - val=dict( - type=dataset_type, - data_root=data_root, - img_dir='JPEGImages', - ann_dir='SegmentationClass', - split='ImageSets/Segmentation/val.txt', - pipeline=test_pipeline), - test=dict( - type=dataset_type, - data_root=data_root, - img_dir='JPEGImages', - ann_dir='SegmentationClass', - split='ImageSets/Segmentation/val.txt', - pipeline=test_pipeline)) diff --git a/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/configs/_base_/models/fpn_r50.py b/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/configs/_base_/models/fpn_r50.py deleted file mode 100644 index 86ab327db92e44c14822d65f1c9277cb007f17c1..0000000000000000000000000000000000000000 --- a/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/configs/_base_/models/fpn_r50.py +++ /dev/null @@ -1,36 +0,0 @@ -# model settings -norm_cfg = dict(type='SyncBN', requires_grad=True) -model = dict( - type='EncoderDecoder', - pretrained='open-mmlab://resnet50_v1c', - backbone=dict( - type='ResNetV1c', - depth=50, - num_stages=4, - out_indices=(0, 1, 2, 3), - dilations=(1, 1, 1, 1), - strides=(1, 2, 2, 2), - norm_cfg=norm_cfg, - norm_eval=False, - style='pytorch', - contract_dilation=True), - neck=dict( - type='FPN', - in_channels=[256, 512, 1024, 2048], - out_channels=256, - num_outs=4), - decode_head=dict( - type='FPNHead', - in_channels=[256, 256, 256, 256], - in_index=[0, 1, 2, 3], - feature_strides=[4, 8, 16, 32], - channels=128, - dropout_ratio=0.1, - num_classes=19, - norm_cfg=norm_cfg, - align_corners=False, - loss_decode=dict( - type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)), - # model training and testing settings - train_cfg=dict(), - test_cfg=dict(mode='whole')) diff --git a/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/mmseg/models/decode_heads/ann_head.py b/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/mmseg/models/decode_heads/ann_head.py deleted file mode 100644 index 30aaacc2cafc568d3de71d1477b4de0dc0fea9d3..0000000000000000000000000000000000000000 --- a/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/mmseg/models/decode_heads/ann_head.py +++ /dev/null @@ -1,245 +0,0 @@ -import torch -import torch.nn as nn -from annotator.uniformer.mmcv.cnn import ConvModule - -from ..builder import HEADS -from ..utils import SelfAttentionBlock as _SelfAttentionBlock -from .decode_head import BaseDecodeHead - - -class PPMConcat(nn.ModuleList): - """Pyramid Pooling Module that only concat the features of each layer. - - Args: - pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid - Module. - """ - - def __init__(self, pool_scales=(1, 3, 6, 8)): - super(PPMConcat, self).__init__( - [nn.AdaptiveAvgPool2d(pool_scale) for pool_scale in pool_scales]) - - def forward(self, feats): - """Forward function.""" - ppm_outs = [] - for ppm in self: - ppm_out = ppm(feats) - ppm_outs.append(ppm_out.view(*feats.shape[:2], -1)) - concat_outs = torch.cat(ppm_outs, dim=2) - return concat_outs - - -class SelfAttentionBlock(_SelfAttentionBlock): - """Make a ANN used SelfAttentionBlock. - - Args: - low_in_channels (int): Input channels of lower level feature, - which is the key feature for self-attention. - high_in_channels (int): Input channels of higher level feature, - which is the query feature for self-attention. - channels (int): Output channels of key/query transform. - out_channels (int): Output channels. - share_key_query (bool): Whether share projection weight between key - and query projection. - query_scale (int): The scale of query feature map. - key_pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid - Module of key feature. - conv_cfg (dict|None): Config of conv layers. - norm_cfg (dict|None): Config of norm layers. - act_cfg (dict|None): Config of activation layers. - """ - - def __init__(self, low_in_channels, high_in_channels, channels, - out_channels, share_key_query, query_scale, key_pool_scales, - conv_cfg, norm_cfg, act_cfg): - key_psp = PPMConcat(key_pool_scales) - if query_scale > 1: - query_downsample = nn.MaxPool2d(kernel_size=query_scale) - else: - query_downsample = None - super(SelfAttentionBlock, self).__init__( - key_in_channels=low_in_channels, - query_in_channels=high_in_channels, - channels=channels, - out_channels=out_channels, - share_key_query=share_key_query, - query_downsample=query_downsample, - key_downsample=key_psp, - key_query_num_convs=1, - key_query_norm=True, - value_out_num_convs=1, - value_out_norm=False, - matmul_norm=True, - with_out=True, - conv_cfg=conv_cfg, - norm_cfg=norm_cfg, - act_cfg=act_cfg) - - -class AFNB(nn.Module): - """Asymmetric Fusion Non-local Block(AFNB) - - Args: - low_in_channels (int): Input channels of lower level feature, - which is the key feature for self-attention. - high_in_channels (int): Input channels of higher level feature, - which is the query feature for self-attention. - channels (int): Output channels of key/query transform. - out_channels (int): Output channels. - and query projection. - query_scales (tuple[int]): The scales of query feature map. - Default: (1,) - key_pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid - Module of key feature. - conv_cfg (dict|None): Config of conv layers. - norm_cfg (dict|None): Config of norm layers. - act_cfg (dict|None): Config of activation layers. - """ - - def __init__(self, low_in_channels, high_in_channels, channels, - out_channels, query_scales, key_pool_scales, conv_cfg, - norm_cfg, act_cfg): - super(AFNB, self).__init__() - self.stages = nn.ModuleList() - for query_scale in query_scales: - self.stages.append( - SelfAttentionBlock( - low_in_channels=low_in_channels, - high_in_channels=high_in_channels, - channels=channels, - out_channels=out_channels, - share_key_query=False, - query_scale=query_scale, - key_pool_scales=key_pool_scales, - conv_cfg=conv_cfg, - norm_cfg=norm_cfg, - act_cfg=act_cfg)) - self.bottleneck = ConvModule( - out_channels + high_in_channels, - out_channels, - 1, - conv_cfg=conv_cfg, - norm_cfg=norm_cfg, - act_cfg=None) - - def forward(self, low_feats, high_feats): - """Forward function.""" - priors = [stage(high_feats, low_feats) for stage in self.stages] - context = torch.stack(priors, dim=0).sum(dim=0) - output = self.bottleneck(torch.cat([context, high_feats], 1)) - return output - - -class APNB(nn.Module): - """Asymmetric Pyramid Non-local Block (APNB) - - Args: - in_channels (int): Input channels of key/query feature, - which is the key feature for self-attention. - channels (int): Output channels of key/query transform. - out_channels (int): Output channels. - query_scales (tuple[int]): The scales of query feature map. - Default: (1,) - key_pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid - Module of key feature. - conv_cfg (dict|None): Config of conv layers. - norm_cfg (dict|None): Config of norm layers. - act_cfg (dict|None): Config of activation layers. - """ - - def __init__(self, in_channels, channels, out_channels, query_scales, - key_pool_scales, conv_cfg, norm_cfg, act_cfg): - super(APNB, self).__init__() - self.stages = nn.ModuleList() - for query_scale in query_scales: - self.stages.append( - SelfAttentionBlock( - low_in_channels=in_channels, - high_in_channels=in_channels, - channels=channels, - out_channels=out_channels, - share_key_query=True, - query_scale=query_scale, - key_pool_scales=key_pool_scales, - conv_cfg=conv_cfg, - norm_cfg=norm_cfg, - act_cfg=act_cfg)) - self.bottleneck = ConvModule( - 2 * in_channels, - out_channels, - 1, - conv_cfg=conv_cfg, - norm_cfg=norm_cfg, - act_cfg=act_cfg) - - def forward(self, feats): - """Forward function.""" - priors = [stage(feats, feats) for stage in self.stages] - context = torch.stack(priors, dim=0).sum(dim=0) - output = self.bottleneck(torch.cat([context, feats], 1)) - return output - - -@HEADS.register_module() -class ANNHead(BaseDecodeHead): - """Asymmetric Non-local Neural Networks for Semantic Segmentation. - - This head is the implementation of `ANNNet - How to Download and Play Extreme Landings Windows Crack Key
-If you are a fan of flight simulation games, you might have heard of Extreme Landings Pro, a realistic and challenging game that lets you test your skills as a pilot in various scenarios. However, if you want to play this game on your Windows 10 PC, you might encounter some difficulties. The game is not officially available for Windows 10, and the only way to get it is to use a crack key that bypasses the security measures of the game.
-Extreme Landings Windows Crack Key
Download Zip ★★★★★ https://urlgoal.com/2uyM6n
-In this article, we will show you how to download and play Extreme Landings Windows Crack Key on your PC, using some simple steps and tools. We will also explain the risks and benefits of using a crack key, and some alternatives that you can try if you don't want to use one.
-What is Extreme Landings Windows Crack Key?
-Extreme Landings Windows Crack Key is a modified version of the original game that allows you to play it on your Windows 10 PC without paying for it or having a license. A crack key is a code that unlocks the features and functions of the game that are normally restricted or encrypted. By using a crack key, you can bypass the verification process of the game and enjoy it for free.
-However, using a crack key also comes with some risks and drawbacks. First of all, it is illegal and unethical to use a crack key, as it violates the terms and conditions of the game developer and publisher. You might face legal consequences or penalties if you are caught using a crack key. Secondly, using a crack key might expose your PC to malware or viruses that can harm your system or steal your data. Thirdly, using a crack key might compromise the quality and performance of the game, as it might not be compatible with your PC specifications or updates. You might experience bugs, glitches, crashes, or errors while playing the game.
-How to Download and Play Extreme Landings Windows Crack Key?
-If you still want to download and play Extreme Landings Windows Crack Key on your PC, you will need to follow these steps:
--
-
- Download an Android emulator on your PC, such as BlueStacks or NoxPlayer. An Android emulator is a software that allows you to run Android apps and games on your PC. -
- Install and launch the Android emulator on your PC. -
- Download Extreme Landings Pro APK + MOD (All Unlocked) from a reliable source on the internet. This is a modified version of the game that has all the content unlocked and does not require a license. -
- Drag and drop the APK file into the Android emulator window, or use the built-in browser to locate and install it. -
- Once the installation is complete, launch Extreme Landings Pro from the emulator home screen. -
- Enjoy playing Extreme Landings Windows Crack Key on your PC. -
What are some alternatives to Extreme Landings Windows Crack Key?
-If you don't want to use a crack key to play Extreme Landings Pro on your PC, you can try some alternatives that are similar or better than this game. Here are some suggestions:
--
-
- Microsoft Flight Simulator: This is one of the most realistic and immersive flight simulation games ever made. It features stunning graphics, dynamic weather, realistic physics, and over 37,000 airports around the world. You can fly any type of aircraft, from light planes to commercial jets, and explore the world in amazing detail. You can also customize your flight plan, weather conditions, time of day, and difficulty level. Microsoft Flight Simulator is available for Windows 10 and Xbox Series X/S. -
- X-Plane 11: This is another realistic and comprehensive flight simulation game that offers a wide range of aircraft, scenery, airports, and features. You can fly anything from gliders to helicopters to space shuttles, and experience realistic flight dynamics, weather effects, sound effects, and lighting effects. You can also create your own aircraft, scenery, airports, and missions with the powerful editing tools. X-Plane 11 is available for Windows 10, Mac OS X, and Linux. -
- Aerofly FS 2020: This is a mobile flight simulation game that delivers high-quality graphics, smooth performance, and easy controls. You can choose from over 200 airports and 21 aircraft models, ranging from single-engine planes to airliners. You can also enjoy realistic cockpit views, instrument displays, navigation systems, weather conditions, and physics. Aerofly FS 2020 is available for Android and iOS devices. -
Conclusion
-In conclusion, Extreme Landings Windows Crack Key is a way to play Extreme Landings Pro on your Windows 10 PC for free by using a modified version of the game that bypasses the security measures. However, using a crack key is illegal, unethical, -risky, -and potentially harmful for your PC -and -the game quality -and performance. -If you want to enjoy -a -flight simulation game on your PC, -you should consider -some alternatives -that are -similar or better than Extreme Landings Pro, -such as Microsoft Flight Simulator, -X-Plane 11, -or Aerofly FS 2020. -These games are -officially available for -Windows 10 -or other platforms, -and offer -a more realistic, -immersive, -and satisfying -flight simulation experience.
- -Why Should You Play Extreme Landings Windows Crack Key?
-Extreme Landings Windows Crack Key is not just a game, but a learning experience. You can improve your knowledge and skills in aviation, navigation, and emergency management. You can face realistic scenarios that challenge your decision-making, problem-solving, and reaction abilities. You can also enjoy the thrill and excitement of flying different types of aircraft in various weather conditions and locations.
-Extreme Landings Windows Crack Key is not just a simulation, but a masterpiece. You can appreciate the stunning graphics, smooth animations, and realistic sound effects that create an immersive atmosphere. You can also explore the detailed and accurate maps, airports, and runways that are based on real-world data. You can also customize your aircraft, flight plan, and difficulty level to suit your preferences and goals.
-How to Get Extreme Landings Windows Crack Key for Free?
-Extreme Landings Windows Crack Key is not just a crack key, but a gift. You can get it for free without paying for the original game or having a license. You can also avoid the verification process of the game and enjoy all the features and functions that are normally restricted or encrypted. You can also access all the content that is unlocked and available in the modified version of the game.
-However, getting Extreme Landings Windows Crack Key for free is not easy or safe. You will need to find a reliable source on the internet that provides the crack key and the modified version of the game. You will also need to download an Android emulator on your PC that allows you to run Android apps and games on your PC. You will also need to install and launch the Android emulator on your PC, drag and drop the APK file into the emulator window, or use the built-in browser to locate and install it. You will also need to launch Extreme Landings Pro from the emulator home screen and enjoy playing Extreme Landings Windows Crack Key on your PC.
-What are some tips and tricks for playing Extreme Landings Windows Crack Key?
-Extreme Landings Windows Crack Key is not just a fun game, but a challenging one. You will need to master some tips and tricks to play it well and complete all the missions and challenges. Here are some suggestions:
--
-
- Use the navigation bar: The navigation bar will help you keep track of your flight path, altitude, speed, fuel level, weather conditions, and other important information. You can also use it to turn on or off autopilot, review your route, control your speed level, and adjust your settings. -
- Manage your engine system: The engine system is vital for your aircraft's performance and safety. You will need to monitor its status and temperature, manage its fuel consumption, activate its APU mode, and deal with any failures or malfunctions that might occur. -
- Operate your landing gear: The landing gear is essential for your aircraft's takeoff and landing. You will need to open or close it within the allowable range, use the brakes properly, check its condition and damage level, and coordinate it with the flap system and reverse. -
- Practice in different modes: The game offers different modes for you to practice and improve your skills. You can try the free flight mode to explore different locations and scenarios without any pressure or objectives. You can also try the landing competition mode to test your landing accuracy and precision against other players online. -
What are some reviews and ratings for Extreme Landings Windows Crack Key?
-Extreme Landings Windows Crack Key is not just a game, but a community. You can share your opinions and feedback with other players online, and read their reviews and ratings for the game. You can also learn from their tips and tricks, and discover their favorite features and functions of the game.
-However, finding reviews and ratings for Extreme Landings Windows Crack Key is not easy or reliable. You will need to search for them on the internet, and filter out the ones that are fake, biased, or outdated. You will also need to be careful of the sources that provide the reviews and ratings, as they might be infected with malware or viruses that can harm your PC or steal your data.
-Here are some examples of reviews and ratings for Extreme Landings Windows Crack Key from different sources:
--
-
- Reddit: A user named SoonlyXo posted a question on r/PiratedGames, asking where or how to crack Extreme Landings Pro for Windows 10. The user received some replies from other users, suggesting to use a cracked Android version of the game, or to download an IPA file from a website. The user also received a comment from AutoModerator, a bot that reminded them to read the stickied megathread that might answer their question. The post received 2 upvotes and 6 comments. -
- SoundCloud: A user named Tracourytsmal1984 uploaded a track titled Extreme Landings Windows Crack Key, which is a 3-minute audio file that contains instructions on how to download and install the game on PC. The user also provided a link to a PDF file that contains more information about the game. The track received no likes or comments. -
- MODYOLO: A website that provides APK and MOD files for Android games and apps. The website has a page for Extreme Landings Pro v3.7.8 APK + MOD (All Unlocked), which is a modified version of the game that has all the content unlocked and does not require a license. The page contains a brief introduction of the game, its features, its mod info, its screenshots, and its download links. The page also has a comment section where users can leave their feedback or ask questions about the game. The page received no ratings or comments. -
How to update Extreme Landings Windows Crack Key?
-Extreme Landings Windows Crack Key is not just a game, but a project. You can expect new updates and improvements for the game from time to time, as the developer and publisher might release new versions of the game that fix bugs, add features, or enhance performance. You can also enjoy new content and challenges that are added to the game with each update.
-However, updating Extreme Landings Windows Crack Key is not easy or automatic. You will need to manually check for updates on the internet, and download and install them on your PC. You will also need to make sure that the updates are compatible with your crack key and your modified version of the game. You might also need to backup your data and settings before updating, as they might be overwritten or deleted by the update.
-Here are some steps to update Extreme Landings Windows Crack Key on your PC:
--
-
- Visit the official website of Extreme Landings Pro or follow its social media accounts to check for any news or announcements about new updates for the game. -
- If there is a new update available, find a reliable source on the internet that provides the update file for Extreme Landings Windows Crack Key. -
- Download the update file on your PC, and scan it with an antivirus software to make sure it is safe and clean. -
- Backup your data and settings of Extreme Landings Windows Crack Key on your PC, such as your progress, achievements, preferences, etc. -
- Close Extreme Landings Pro if it is running on your PC. -
- Run the update file on your PC, and follow the instructions to install it. -
- Launch Extreme Landings Pro from your Android emulator home screen. -
- Enjoy playing Extreme Landings Windows Crack Key with the latest update. -
Conclusion
-In conclusion, Extreme Landings Windows Crack Key is a way to play Extreme Landings Pro on your Windows 10 PC for free by using a modified version of the game that bypasses the security measures. However, using a crack key is illegal, unethical, risky, and potentially harmful for your PC and the game quality and performance. If you want to enjoy a flight simulation game on your PC, you should consider some alternatives that are similar or better than Extreme Landings Pro, such as Microsoft Flight Simulator, X-Plane 11, or Aerofly FS 2020. These games are officially available for Windows 10 or other platforms, and offer a more realistic, immersive, and satisfying flight simulation experience.
3cee63e6c2
-
-
\ No newline at end of file diff --git a/spaces/group2test/stable-diffusion-v1-5/app.py b/spaces/group2test/stable-diffusion-v1-5/app.py deleted file mode 100644 index 2013a8fe01c8fdf93c87412e5f9c83d9c8501b5b..0000000000000000000000000000000000000000 --- a/spaces/group2test/stable-diffusion-v1-5/app.py +++ /dev/null @@ -1,137 +0,0 @@ -from diffusers import StableDiffusionPipeline, StableDiffusionImg2ImgPipeline, DPMSolverMultistepScheduler -import gradio as gr -import torch -from PIL import Image - -model_id = 'runwayml/stable-diffusion-v1-5' -prefix = '' - -scheduler = DPMSolverMultistepScheduler.from_pretrained(model_id, subfolder="scheduler") - -pipe = StableDiffusionPipeline.from_pretrained( - model_id, - torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32, - scheduler=scheduler) - -pipe_i2i = StableDiffusionImg2ImgPipeline.from_pretrained( - model_id, - torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32, - scheduler=scheduler) - -if torch.cuda.is_available(): - pipe = pipe.to("cuda") - pipe_i2i = pipe_i2i.to("cuda") - -def error_str(error, title="Error"): - return f"""#### {title} - {error}""" if error else "" - -def inference(prompt, guidance, steps, width=512, height=512, seed=0, img=None, strength=0.5, neg_prompt="", auto_prefix=False): - - generator = torch.Generator('cuda').manual_seed(seed) if seed != 0 else None - prompt = f"{prefix} {prompt}" if auto_prefix else prompt - - try: - if img is not None: - return img_to_img(prompt, neg_prompt, img, strength, guidance, steps, width, height, generator), None - else: - return txt_to_img(prompt, neg_prompt, guidance, steps, width, height, generator), None - except Exception as e: - return None, error_str(e) - -def txt_to_img(prompt, neg_prompt, guidance, steps, width, height, generator): - - result = pipe( - prompt, - negative_prompt = neg_prompt, - num_inference_steps = int(steps), - guidance_scale = guidance, - width = width, - height = height, - generator = generator) - - return result.images[0] - -def img_to_img(prompt, neg_prompt, img, strength, guidance, steps, width, height, generator): - - ratio = min(height / img.height, width / img.width) - img = img.resize((int(img.width * ratio), int(img.height * ratio)), Image.LANCZOS) - result = pipe_i2i( - prompt, - negative_prompt = neg_prompt, - init_image = img, - num_inference_steps = int(steps), - strength = strength, - guidance_scale = guidance, - width = width, - height = height, - generator = generator) - - return result.images[0] - -css = """.main-div div{display:inline-flex;align-items:center;gap:.8rem;font-size:1.75rem}.main-div div h1{font-weight:900;margin-bottom:7px}.main-div p{margin-bottom:10px;font-size:94%}a{text-decoration:underline}.tabs{margin-top:0;margin-bottom:0}#gallery{min-height:20rem} -""" -with gr.Blocks(css=css) as demo: - gr.HTML( - f""" --- """ - ) - with gr.Row(): - - with gr.Column(scale=55): - with gr.Group(): - with gr.Row(): - prompt = gr.Textbox(label="Prompt", show_label=False, max_lines=2,placeholder=f"{prefix} [your prompt]").style(container=False) - generate = gr.Button(value="Generate").style(rounded=(False, True, True, False)) - - image_out = gr.Image(height=512) - error_output = gr.Markdown() - - with gr.Column(scale=45): - with gr.Tab("Options"): - with gr.Group(): - neg_prompt = gr.Textbox(label="Negative prompt", placeholder="What to exclude from the image") - auto_prefix = gr.Checkbox(label="Prefix styling tokens automatically ()", value=prefix, visible=prefix) - - with gr.Row(): - guidance = gr.Slider(label="Guidance scale", value=7.5, maximum=15) - steps = gr.Slider(label="Steps", value=25, minimum=2, maximum=75, step=1) - - with gr.Row(): - width = gr.Slider(label="Width", value=512, minimum=64, maximum=1024, step=8) - height = gr.Slider(label="Height", value=512, minimum=64, maximum=1024, step=8) - - seed = gr.Slider(0, 2147483647, label='Seed (0 = random)', value=0, step=1) - - with gr.Tab("Image to image"): - with gr.Group(): - image = gr.Image(label="Image", height=256, tool="editor", type="pil") - strength = gr.Slider(label="Transformation strength", minimum=0, maximum=1, step=0.01, value=0.5) - - auto_prefix.change(lambda x: gr.update(placeholder=f"{prefix} [your prompt]" if x else "[Your prompt]"), inputs=auto_prefix, outputs=prompt, queue=False) - - inputs = [prompt, guidance, steps, width, height, seed, image, strength, neg_prompt, auto_prefix] - outputs = [image_out, error_output] - prompt.submit(inference, inputs=inputs, outputs=outputs) - generate.click(inference, inputs=inputs, outputs=outputs) - - gr.HTML(""" ---Stable Diffusion V1 5
-- Demo for Stable Diffusion V1 5 Stable Diffusion model.
- Running on {"GPU 🔥" if torch.cuda.is_available() else f"CPU 🥶. For faster inference it is recommended to upgrade to GPU in Settings"} after duplicating the space
- {"Add the following tokens to your prompts for the model to work properly: prefix" if prefix else ""} -
--- """) - -demo.queue(concurrency_count=1) -demo.launch() diff --git a/spaces/gsaivinay/open_llm_leaderboard/src/display_models/get_model_metadata.py b/spaces/gsaivinay/open_llm_leaderboard/src/display_models/get_model_metadata.py deleted file mode 100644 index ebeee76061650664b00259fe980ce05f013a0e9c..0000000000000000000000000000000000000000 --- a/spaces/gsaivinay/open_llm_leaderboard/src/display_models/get_model_metadata.py +++ /dev/null @@ -1,180 +0,0 @@ -import glob -import json -import os -import pickle -import re -from typing import List - -import huggingface_hub -from accelerate import init_empty_weights -from huggingface_hub import HfApi -from tqdm import tqdm -from transformers import AutoConfig, AutoModel - -from src.display_models.model_metadata_flags import DO_NOT_SUBMIT_MODELS, FLAGGED_MODELS -from src.display_models.model_metadata_type import MODEL_TYPE_METADATA, ModelType, model_type_from_str -from src.display_models.utils import AutoEvalColumn, model_hyperlink - -api = HfApi(token=os.environ.get("H4_TOKEN", None)) - - -def get_model_infos_from_hub(leaderboard_data: List[dict]): - # load cache from disk - try: - with open("model_info_cache.pkl", "rb") as f: - model_info_cache = pickle.load(f) - except (EOFError, FileNotFoundError): - model_info_cache = {} - try: - with open("model_size_cache.pkl", "rb") as f: - model_size_cache = pickle.load(f) - except (EOFError, FileNotFoundError): - model_size_cache = {} - try: - with open("model_size_cache.pkl", "rb") as f: - model_size_cache = pickle.load(f) - except (EOFError, FileNotFoundError): - model_size_cache = {} - - for model_data in tqdm(leaderboard_data): - model_name = model_data["model_name_for_query"] - - if model_name in model_info_cache: - model_info = model_info_cache[model_name] - else: - try: - model_info = api.model_info(model_name) - model_info_cache[model_name] = model_info - except huggingface_hub.utils._errors.RepositoryNotFoundError: - print("Repo not found!", model_name) - model_data[AutoEvalColumn.license.name] = None - model_data[AutoEvalColumn.likes.name] = None - if model_name not in model_size_cache: - model_size_cache[model_name] = get_model_size(model_name, None) - model_data[AutoEvalColumn.params.name] = model_size_cache[model_name] - if model_name not in model_size_cache: - model_size_cache[model_name] = get_model_size(model_name, None) - model_data[AutoEvalColumn.params.name] = model_size_cache[model_name] - - model_data[AutoEvalColumn.license.name] = get_model_license(model_info) - model_data[AutoEvalColumn.likes.name] = get_model_likes(model_info) - if model_name not in model_size_cache: - model_size_cache[model_name] = get_model_size(model_name, model_info) - model_data[AutoEvalColumn.params.name] = model_size_cache[model_name] - if model_name not in model_size_cache: - model_size_cache[model_name] = get_model_size(model_name, model_info) - model_data[AutoEvalColumn.params.name] = model_size_cache[model_name] - - # save cache to disk in pickle format - with open("model_info_cache.pkl", "wb") as f: - pickle.dump(model_info_cache, f) - with open("model_size_cache.pkl", "wb") as f: - pickle.dump(model_size_cache, f) - with open("model_size_cache.pkl", "wb") as f: - pickle.dump(model_size_cache, f) - - -def get_model_license(model_info): - try: - return model_info.cardData["license"] - except Exception: - return "?" - - -def get_model_likes(model_info): - return model_info.likes - - -size_pattern = re.compile(r"(\d\.)?\d+(b|m)") - - -def get_model_size(model_name, model_info): - # In billions - try: - return round(model_info.safetensors["total"] / 1e9, 3) - except AttributeError: - try: - config = AutoConfig.from_pretrained(model_name, trust_remote_code=False) - with init_empty_weights(): - model = AutoModel.from_config(config, trust_remote_code=False) - return round(sum(p.numel() for p in model.parameters() if p.requires_grad) / 1e9, 3) - except (EnvironmentError, ValueError, KeyError): # model config not found, likely private - try: - size_match = re.search(size_pattern, model_name.lower()) - size = size_match.group(0) - return round(float(size[:-1]) if size[-1] == "b" else float(size[:-1]) / 1e3, 3) - except AttributeError: - return 0 - - -def get_model_type(leaderboard_data: List[dict]): - for model_data in leaderboard_data: - request_files = os.path.join( - "eval-queue", - model_data["model_name_for_query"] + "_eval_request_*" + ".json", - ) - request_files = glob.glob(request_files) - - # Select correct request file (precision) - request_file = "" - if len(request_files) == 1: - request_file = request_files[0] - elif len(request_files) > 1: - request_files = sorted(request_files, reverse=True) - for tmp_request_file in request_files: - with open(tmp_request_file, "r") as f: - req_content = json.load(f) - if ( - req_content["status"] == "FINISHED" - and req_content["precision"] == model_data["Precision"].split(".")[-1] - ): - request_file = tmp_request_file - - try: - with open(request_file, "r") as f: - request = json.load(f) - model_type = model_type_from_str(request["model_type"]) - model_data[AutoEvalColumn.model_type.name] = model_type.value.name - model_data[AutoEvalColumn.model_type_symbol.name] = model_type.value.symbol # + ("🔺" if is_delta else "") - except Exception: - if model_data["model_name_for_query"] in MODEL_TYPE_METADATA: - model_data[AutoEvalColumn.model_type.name] = MODEL_TYPE_METADATA[ - model_data["model_name_for_query"] - ].value.name - model_data[AutoEvalColumn.model_type_symbol.name] = MODEL_TYPE_METADATA[ - model_data["model_name_for_query"] - ].value.symbol # + ("🔺" if is_delta else "") - else: - model_data[AutoEvalColumn.model_type.name] = ModelType.Unknown.value.name - model_data[AutoEvalColumn.model_type_symbol.name] = ModelType.Unknown.value.symbol - - -def flag_models(leaderboard_data: List[dict]): - for model_data in leaderboard_data: - if model_data["model_name_for_query"] in FLAGGED_MODELS: - issue_num = FLAGGED_MODELS[model_data["model_name_for_query"]].split("/")[-1] - issue_link = model_hyperlink( - FLAGGED_MODELS[model_data["model_name_for_query"]], - f"See discussion #{issue_num}", - ) - model_data[ - AutoEvalColumn.model.name - ] = f"{model_data[AutoEvalColumn.model.name]} has been flagged! {issue_link}" - - -def remove_forbidden_models(leaderboard_data: List[dict]): - indices_to_remove = [] - for ix, model in enumerate(leaderboard_data): - if model["model_name_for_query"] in DO_NOT_SUBMIT_MODELS: - indices_to_remove.append(ix) - - for ix in reversed(indices_to_remove): - leaderboard_data.pop(ix) - return leaderboard_data - - -def apply_metadata(leaderboard_data: List[dict]): - leaderboard_data = remove_forbidden_models(leaderboard_data) - get_model_type(leaderboard_data) - get_model_infos_from_hub(leaderboard_data) - flag_models(leaderboard_data) diff --git a/spaces/gwang-kim/DATID-3D/pose_estimation/nvdiffrast/setup.py b/spaces/gwang-kim/DATID-3D/pose_estimation/nvdiffrast/setup.py deleted file mode 100644 index 889c87521642305e62815f32d6a42c7b307852a0..0000000000000000000000000000000000000000 --- a/spaces/gwang-kim/DATID-3D/pose_estimation/nvdiffrast/setup.py +++ /dev/null @@ -1,46 +0,0 @@ -# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. -# -# NVIDIA CORPORATION and its licensors retain all intellectual property -# and proprietary rights in and to this software, related documentation -# and any modifications thereto. Any use, reproduction, disclosure or -# distribution of this software and related documentation without an express -# license agreement from NVIDIA CORPORATION is strictly prohibited. - -from pose_estimation.nvdiffrast import nvdiffrast -import setuptools -import os - -with open("README.md", "r") as fh: - long_description = fh.read() - -setuptools.setup( - name="nvdiffrast", - version=nvdiffrast.__version__, - author="Samuli Laine", - author_email="slaine@nvidia.com", - description="nvdiffrast - modular primitives for high-performance differentiable rendering", - long_description=long_description, - long_description_content_type="text/markdown", - url="https://github.com/NVlabs/nvdiffrast", - packages=setuptools.find_packages(), - package_data={ - 'nvdiffrast': [ - 'common/*.h', - 'common/*.inl', - 'common/*.cu', - 'common/*.cpp', - 'lib/*.h', - 'torch/*.h', - 'torch/*.inl', - 'torch/*.cpp', - 'tensorflow/*.cu', - ] + (['lib/*.lib'] if os.name == 'nt' else []) - }, - include_package_data=True, - install_requires=['numpy'], # note: can't require torch here as it will install torch even for a TensorFlow container - classifiers=[ - "Programming Language :: Python :: 3", - "Operating System :: OS Independent", - ], - python_requires='>=3.6', -) diff --git a/spaces/gyugnsu/DragGan-Inversion/stylegan_human/pti/pti_configs/__init__.py b/spaces/gyugnsu/DragGan-Inversion/stylegan_human/pti/pti_configs/__init__.py deleted file mode 100644 index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000 diff --git a/spaces/haakohu/deep_privacy2/configs/fdf/stylegan_fdf128.py b/spaces/haakohu/deep_privacy2/configs/fdf/stylegan_fdf128.py deleted file mode 100644 index a47d6d2ee362c935e7879c9442c4dcd9aaf007c0..0000000000000000000000000000000000000000 --- a/spaces/haakohu/deep_privacy2/configs/fdf/stylegan_fdf128.py +++ /dev/null @@ -1,17 +0,0 @@ -from ..discriminators.sg2_discriminator import discriminator, G_optim, D_optim, loss_fnc -from ..datasets.fdf128 import data -from ..generators.stylegan_unet import generator -from ..defaults import train, common, EMA -from tops.config import LazyCall as L - -G_optim.lr = 0.002 -D_optim.lr = 0.002 -generator.update(cnum=128, max_cnum_mul=4, input_cse=False) -loss_fnc.r1_opts.lambd = 0.1 - -train.update(ims_per_val=int(2e6), batch_size=64, max_images_to_train=int(35e6)) - -common.update( - model_url="https://api.loke.aws.unit.no/dlr-gui-backend-resources-content/v2/contents/links/66d803c0-55ce-44c0-9d53-815c2c0e6ba4eb458409-9e91-45d1-bce0-95c8a47a57218b102fdf-bea3-44dc-aac4-0fb1d370ef1c", - model_md5sum="bccd4403e7c9bca682566ff3319e8176" -) \ No newline at end of file diff --git a/spaces/hahahafofo/image2text_prompt_generator/utils/exif.py b/spaces/hahahafofo/image2text_prompt_generator/utils/exif.py deleted file mode 100644 index fef7a34cc83697a32b25eef46a776dfe4228977b..0000000000000000000000000000000000000000 --- a/spaces/hahahafofo/image2text_prompt_generator/utils/exif.py +++ /dev/null @@ -1,54 +0,0 @@ -import piexif -import piexif.helper -from .html import plaintext_to_html - - -def get_image_info(rawimage): - items = rawimage.info - geninfo = "" - - if "exif" in rawimage.info: - exif = piexif.load(rawimage.info["exif"]) - exif_comment = (exif or {}).get("Exif", {}).get(piexif.ExifIFD.UserComment, b"") - try: - exif_comment = piexif.helper.UserComment.load(exif_comment) - except ValueError: - exif_comment = exif_comment.decode("utf8", errors="ignore") - - items["exif comment"] = exif_comment - geninfo = exif_comment - - for field in [ - "jfif", - "jfif_version", - "jfif_unit", - "jfif_density", - "dpi", - "exif", - "loop", - "background", - "timestamp", - "duration", - ]: - items.pop(field, None) - - geninfo = items.get("parameters", geninfo) - - info = f""" -
-This space was created using SD Space Creator.
-PNG Info
- """ - for key, text in items.items(): - info += ( - f""" --- """.strip() - + "\n" - ) - - if len(info) == 0: - message = "Nothing found in the image." - info = f"{plaintext_to_html(str(key))}
-{plaintext_to_html(str(text))}
-" - return info diff --git a/spaces/hamzapehlivan/StyleRes/models/e4e.py b/spaces/hamzapehlivan/StyleRes/models/e4e.py deleted file mode 100644 index 9b7247baf03fe27972b3b434b6270cee1a9ccc05..0000000000000000000000000000000000000000 --- a/spaces/hamzapehlivan/StyleRes/models/e4e.py +++ /dev/null @@ -1,348 +0,0 @@ -import math -import numpy as np -import torch -import torch.nn as nn -import torch.nn.functional as F -from collections import namedtuple - -def _upsample_add(x, y): - _, _, H, W = y.size() - return F.interpolate(x, size=(H, W), mode='bilinear', align_corners=True) + y - - - -class EqualLinear(nn.Module): - def __init__( - self, in_dim, out_dim, bias=True, bias_init=0, lr_mul=1, activation=None - ): - super().__init__() - - self.weight = nn.Parameter(torch.randn(out_dim, in_dim).div_(lr_mul)) - - if bias: - self.bias = nn.Parameter(torch.zeros(out_dim).fill_(bias_init)) - - else: - self.bias = None - - self.activation = activation - - self.scale = (1 / math.sqrt(in_dim)) * lr_mul - self.lr_mul = lr_mul - - def forward(self, input): - # if self.activation: - # out = F.linear(input, self.weight * self.scale) - # out = fused_leaky_relu(out, self.bias * self.lr_mul) - - # else: - out = F.linear( - input, self.weight * self.scale, bias=self.bias * self.lr_mul - ) - - return out - - def __repr__(self): - return ( - f'{self.__class__.__name__}({self.weight.shape[1]}, {self.weight.shape[0]})' - ) - -class GradualStyleBlock(nn.Module): - def __init__(self, in_c, out_c, spatial): - super(GradualStyleBlock, self).__init__() - self.out_c = out_c - self.spatial = spatial - num_pools = int(np.log2(spatial)) - modules = [] - modules += [nn.Conv2d(in_c, out_c, kernel_size=3, stride=2, padding=1), - nn.LeakyReLU()] - for i in range(num_pools - 1): - modules += [ - nn.Conv2d(out_c, out_c, kernel_size=3, stride=2, padding=1), - nn.LeakyReLU() - ] - self.convs = nn.Sequential(*modules) - self.linear = EqualLinear(out_c, out_c, lr_mul=1) - - def forward(self, x): - x = self.convs(x) - x = x.view(-1, self.out_c) - x = self.linear(x) - return x - -class Bottleneck(namedtuple('Block', ['in_channel', 'depth', 'stride'])): - """ A named tuple describing a ResNet block. """ - -class bottleneck_IR(nn.Module): - def __init__(self, in_channel, depth, stride): - super(bottleneck_IR, self).__init__() - if in_channel == depth: - self.shortcut_layer = nn.MaxPool2d(1, stride) - else: - self.shortcut_layer = nn.Sequential( - nn.Conv2d(in_channel, depth, (1, 1), stride, bias=False), - nn.BatchNorm2d(depth) - ) - self.res_layer = nn.Sequential( - nn.BatchNorm2d(in_channel), - nn.Conv2d(in_channel, depth, (3, 3), (1, 1), 1, bias=False), nn.PReLU(depth), - nn.Conv2d(depth, depth, (3, 3), stride, 1, bias=False), nn.BatchNorm2d(depth) - ) - - def forward(self, x): - shortcut = self.shortcut_layer(x) - res = self.res_layer(x) - return res + shortcut - -class SEModule(nn.Module): - def __init__(self, channels, reduction): - super(SEModule, self).__init__() - self.avg_pool = nn.AdaptiveAvgPool2d(1) - self.fc1 = nn.Conv2d(channels, channels // reduction, kernel_size=1, padding=0, bias=False) - self.relu = nn.ReLU(inplace=True) - self.fc2 = nn.Conv2d(channels // reduction, channels, kernel_size=1, padding=0, bias=False) - self.sigmoid = nn.Sigmoid() - - def forward(self, x): - module_input = x - x = self.avg_pool(x) - x = self.fc1(x) - x = self.relu(x) - x = self.fc2(x) - x = self.sigmoid(x) - return module_input * x - -class bottleneck_IR_SE(nn.Module): - def __init__(self, in_channel, depth, stride): - super(bottleneck_IR_SE, self).__init__() - if in_channel == depth: - self.shortcut_layer = nn.MaxPool2d(1, stride) - else: - self.shortcut_layer = nn.Sequential( - nn.Conv2d(in_channel, depth, (1, 1), stride, bias=False), - nn.BatchNorm2d(depth) - ) - self.res_layer = nn.Sequential( - nn.BatchNorm2d(in_channel), - nn.Conv2d(in_channel, depth, (3, 3), (1, 1), 1, bias=False), - nn.PReLU(depth), - nn.Conv2d(depth, depth, (3, 3), stride, 1, bias=False), - nn.BatchNorm2d(depth), - SEModule(depth, 16) - ) - - def forward(self, x): - shortcut = self.shortcut_layer(x) - res = self.res_layer(x) - return res + shortcut - - -def get_block(in_channel, depth, num_units, stride=2): - return [Bottleneck(in_channel, depth, stride)] + [Bottleneck(depth, depth, 1) for i in range(num_units - 1)] - -def get_blocks(num_layers): - if num_layers == 50: - blocks = [ - get_block(in_channel=64, depth=64, num_units=3), - get_block(in_channel=64, depth=128, num_units=4), - get_block(in_channel=128, depth=256, num_units=14), - get_block(in_channel=256, depth=512, num_units=3) - ] - elif num_layers == 100: - blocks = [ - get_block(in_channel=64, depth=64, num_units=3), - get_block(in_channel=64, depth=128, num_units=13), - get_block(in_channel=128, depth=256, num_units=30), - get_block(in_channel=256, depth=512, num_units=3) - ] - elif num_layers == 152: - blocks = [ - get_block(in_channel=64, depth=64, num_units=3), - get_block(in_channel=64, depth=128, num_units=8), - get_block(in_channel=128, depth=256, num_units=36), - get_block(in_channel=256, depth=512, num_units=3) - ] - else: - raise ValueError("Invalid number of layers: {}. Must be one of [50, 100, 152]".format(num_layers)) - return blocks - -class Encoder4Editing(nn.Module): - def __init__(self, num_layers, mode='ir', stylegan_size=1024, out_res=64): - super(Encoder4Editing, self).__init__() - assert num_layers in [50, 100, 152], 'num_layers should be 50,100, or 152' - assert mode in ['ir', 'ir_se'], 'mode should be ir or ir_se' - blocks = get_blocks(num_layers) - if mode == 'ir': - unit_module = bottleneck_IR - elif mode == 'ir_se': - unit_module = bottleneck_IR_SE - self.out_res = out_res - self.input_layer = nn.Sequential(nn.Conv2d(3, 64, (3, 3), 1, 1, bias=False), - nn.BatchNorm2d(64), - nn.PReLU(64)) - modules = [] - for block in blocks: - for bottleneck in block: - modules.append(unit_module(bottleneck.in_channel, - bottleneck.depth, - bottleneck.stride)) - self.body = nn.Sequential(*modules) - - self.styles = nn.ModuleList() - log_size = int(math.log(stylegan_size, 2)) - self.style_count = 2 * log_size - 2 - self.coarse_ind = 3 - self.middle_ind = 7 - - for i in range(self.style_count): - if i < self.coarse_ind: - style = GradualStyleBlock(512, 512, 16) - elif i < self.middle_ind: - style = GradualStyleBlock(512, 512, 32) - else: - style = GradualStyleBlock(512, 512, 64) - self.styles.append(style) - - self.latlayer1 = nn.Conv2d(256, 512, kernel_size=1, stride=1, padding=0) - self.latlayer2 = nn.Conv2d(128, 512, kernel_size=1, stride=1, padding=0) - - def forward(self, x): - x = self.input_layer(x) - - modulelist = list(self.body._modules.values()) - for i, l in enumerate(modulelist): - x = l(x) - if i == 2: - c0 = x - if i == 6: - c1 = x - elif i == 20: - c2 = x - elif i == 23: - c3 = x - - # Infer main W and duplicate it - w0 = self.styles[0](c3) - w = w0.repeat(self.style_count, 1, 1).permute(1, 0, 2) - - features = c3 - for i in range(1, self.style_count): # Infer additional deltas - if i == self.coarse_ind: - p2 = _upsample_add(c3, self.latlayer1(c2)) # FPN's middle features - features = p2 - elif i == self.middle_ind: - p1 = _upsample_add(p2, self.latlayer2(c1)) # FPN's fine features - features = p1 - delta_i = self.styles[i](features) - w[:, i] += delta_i - - c = { 128: c0, - 64: c1, - 32: c2, - 16: c3 - }.get(self.out_res) - return w, c - -class EqualConv2d(nn.Module): - def __init__( - self, in_channel, out_channel, kernel_size, stride=1, padding=0, bias=True - ): - super().__init__() - - self.weight = nn.Parameter( - torch.randn(out_channel, in_channel, kernel_size, kernel_size) - ) - self.scale = 1 / math.sqrt(in_channel * kernel_size ** 2) - - self.stride = stride - self.padding = padding - - if bias: - self.bias = nn.Parameter(torch.zeros(out_channel)) - - else: - self.bias = None - - def forward(self, input): - out = F.conv2d( - input, - self.weight * self.scale, - bias=self.bias, - stride=self.stride, - padding=self.padding, - ) - - return out - - def __repr__(self): - return ( - f'{self.__class__.__name__}({self.weight.shape[1]}, {self.weight.shape[0]},' - f' {self.weight.shape[2]}, stride={self.stride}, padding={self.padding})' - ) - -class ScaledLeakyReLU(nn.Module): - def __init__(self, negative_slope=0.2): - super().__init__() - - self.negative_slope = negative_slope - - def forward(self, input): - out = F.leaky_relu(input, negative_slope=self.negative_slope) - - return out * math.sqrt(2) - -class HighResFeat(nn.Module): - def __init__(self, in_channels, out_channels): - super(HighResFeat, self).__init__() - - self.shared = EqualConv2d(in_channels, out_channels, kernel_size=3, padding=1, bias=True) - - self.conv1 = EqualConv2d(out_channels, 1, kernel_size=3, padding=1, bias=True) - self.conv2 = EqualConv2d(out_channels, out_channels, kernel_size=3, padding=1, bias=True) - self.activation = ScaledLeakyReLU(0.2) - - self.sigmoid = nn.Sigmoid() - - self.skip = None - if in_channels != out_channels: - self.skip = EqualConv2d(in_channels, out_channels, kernel_size=1, padding=0, bias=False) - - def forward(self, x): - - shared_feats = self.shared(x) - shared_feats = self.activation(shared_feats) - - gate = self.conv1(shared_feats) - gate = self.sigmoid(gate) - - addition = self.conv2(shared_feats) - addition = self.activation(addition) - - if self.skip is not None: - x = self.skip(x) - return gate, addition+x - -class E4E_Inversion(nn.Module): - def __init__(self, resolution, num_layers = 50, mode='ir_se', out_res=64): - super(E4E_Inversion, self).__init__() - self.out_res = out_res - resolution = 1024 - self.basic_encoder = Encoder4Editing(num_layers, mode, resolution, self.out_res) - self.latent_avg = None - # ckpt = torch.load(e4e_path, map_location='cpu') - # self.latent_avg = ckpt['latent_avg'].cuda() - # ckpt = {k[k.find(".")+1:]: v for k, v in ckpt['state_dict'].items() if "decoder" not in k} - # self.basic_encoder.load_state_dict(ckpt, strict=True) - - def freeze_basic_encoder(self): - self.basic_encoder.eval() #Basic Encoder always in eval mode. - #No backprop to basic Encoder - for param in self.basic_encoder.parameters(): - param.requires_grad = False - - def forward(self, reals): - self.freeze_basic_encoder() - w, c = self.basic_encoder(reals) - w = w + self.latent_avg - highres_outs = {f"{self.out_res}x{self.out_res}": c} #{"gates": gates, "additions": additions} - return w, highres_outs diff --git a/spaces/hands012/gpt-academic/crazy_functions/test_project/cpp/cppipc/prod_cons.h b/spaces/hands012/gpt-academic/crazy_functions/test_project/cpp/cppipc/prod_cons.h deleted file mode 100644 index c9004bb8043a12e32814436baa6262a00c8ef68e..0000000000000000000000000000000000000000 --- a/spaces/hands012/gpt-academic/crazy_functions/test_project/cpp/cppipc/prod_cons.h +++ /dev/null @@ -1,433 +0,0 @@ -#pragma once - -#include{message}
-#include -#include -#include -#include - -#include "libipc/def.h" - -#include "libipc/platform/detail.h" -#include "libipc/circ/elem_def.h" -#include "libipc/utility/log.h" -#include "libipc/utility/utility.h" - -namespace ipc { - -//////////////////////////////////////////////////////////////// -/// producer-consumer implementation -//////////////////////////////////////////////////////////////// - -template -struct prod_cons_impl; - -template <> -struct prod_cons_impl - bool push(W* /*wrapper*/, F&& f, E* elems) { - auto cur_wt = circ::index_of(wt_.load(std::memory_order_relaxed)); - if (cur_wt == circ::index_of(rd_.load(std::memory_order_acquire) - 1)) { - return false; // full - } - std::forward (f)(&(elems[cur_wt].data_)); - wt_.fetch_add(1, std::memory_order_release); - return true; - } - - /** - * In single-single-unicast, 'force_push' means 'no reader' or 'the only one reader is dead'. - * So we could just disconnect all connections of receiver, and return false. - */ - template - bool force_push(W* wrapper, F&&, E*) { - wrapper->elems()->disconnect_receiver(~static_cast - bool pop(W* /*wrapper*/, circ::u2_t& /*cur*/, F&& f, R&& out, E* elems) { - auto cur_rd = circ::index_of(rd_.load(std::memory_order_relaxed)); - if (cur_rd == circ::index_of(wt_.load(std::memory_order_acquire))) { - return false; // empty - } - std::forward (f)(&(elems[cur_rd].data_)); - std::forward (out)(true); - rd_.fetch_add(1, std::memory_order_release); - return true; - } -}; - -template <> -struct prod_cons_impl - bool force_push(W* wrapper, F&&, E*) { - wrapper->elems()->disconnect_receiver(1); - return false; - } - - template class E, std::size_t DS, std::size_t AS> - bool pop(W* /*wrapper*/, circ::u2_t& /*cur*/, F&& f, R&& out, E (f)(buff); - std::forward (out)(true); - return true; - } - ipc::yield(k); - } - } -}; - -template <> -struct prod_cons_impl f_ct_ { 0 }; // commit flag - }; - - alignas(cache_line_size) std::atomic - bool push(W* /*wrapper*/, F&& f, E* elems) { - circ::u2_t cur_ct, nxt_ct; - for (unsigned k = 0;;) { - cur_ct = ct_.load(std::memory_order_relaxed); - if (circ::index_of(nxt_ct = cur_ct + 1) == - circ::index_of(rd_.load(std::memory_order_acquire))) { - return false; // full - } - if (ct_.compare_exchange_weak(cur_ct, nxt_ct, std::memory_order_acq_rel)) { - break; - } - ipc::yield(k); - } - auto* el = elems + circ::index_of(cur_ct); - std::forward (f)(&(el->data_)); - // set flag & try update wt - el->f_ct_.store(~static_cast (cur_ct), std::memory_order_release); - while (1) { - auto cac_ct = el->f_ct_.load(std::memory_order_acquire); - if (cur_ct != wt_.load(std::memory_order_relaxed)) { - return true; - } - if ((~cac_ct) != cur_ct) { - return true; - } - if (!el->f_ct_.compare_exchange_strong(cac_ct, 0, std::memory_order_relaxed)) { - return true; - } - wt_.store(nxt_ct, std::memory_order_release); - cur_ct = nxt_ct; - nxt_ct = cur_ct + 1; - el = elems + circ::index_of(cur_ct); - } - return true; - } - - template - bool force_push(W* wrapper, F&&, E*) { - wrapper->elems()->disconnect_receiver(1); - return false; - } - - template class E, std::size_t DS, std::size_t AS> - bool pop(W* /*wrapper*/, circ::u2_t& /*cur*/, F&& f, R&& out, E (f)(buff); - std::forward (out)(true); - return true; - } - ipc::yield(k); - } - } - } -}; - -template <> -struct prod_cons_impl rc_ { 0 }; // read-counter - }; - - alignas(cache_line_size) std::atomic - bool push(W* wrapper, F&& f, E* elems) { - E* el; - for (unsigned k = 0;;) { - circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed); - if (cc == 0) return false; // no reader - el = elems + circ::index_of(wt_.load(std::memory_order_relaxed)); - // check all consumers have finished reading this element - auto cur_rc = el->rc_.load(std::memory_order_acquire); - circ::cc_t rem_cc = cur_rc & ep_mask; - if ((cc & rem_cc) && ((cur_rc & ~ep_mask) == epoch_)) { - return false; // has not finished yet - } - // consider rem_cc to be 0 here - if (el->rc_.compare_exchange_weak( - cur_rc, epoch_ | static_cast (cc), std::memory_order_release)) { - break; - } - ipc::yield(k); - } - std::forward (f)(&(el->data_)); - wt_.fetch_add(1, std::memory_order_release); - return true; - } - - template - bool force_push(W* wrapper, F&& f, E* elems) { - E* el; - epoch_ += ep_incr; - for (unsigned k = 0;;) { - circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed); - if (cc == 0) return false; // no reader - el = elems + circ::index_of(wt_.load(std::memory_order_relaxed)); - // check all consumers have finished reading this element - auto cur_rc = el->rc_.load(std::memory_order_acquire); - circ::cc_t rem_cc = cur_rc & ep_mask; - if (cc & rem_cc) { - ipc::log("force_push: k = %u, cc = %u, rem_cc = %u\n", k, cc, rem_cc); - cc = wrapper->elems()->disconnect_receiver(rem_cc); // disconnect all invalid readers - if (cc == 0) return false; // no reader - } - // just compare & exchange - if (el->rc_.compare_exchange_weak( - cur_rc, epoch_ | static_cast (cc), std::memory_order_release)) { - break; - } - ipc::yield(k); - } - std::forward (f)(&(el->data_)); - wt_.fetch_add(1, std::memory_order_release); - return true; - } - - template - bool pop(W* wrapper, circ::u2_t& cur, F&& f, R&& out, E* elems) { - if (cur == cursor()) return false; // acquire - auto* el = elems + circ::index_of(cur++); - std::forward (f)(&(el->data_)); - for (unsigned k = 0;;) { - auto cur_rc = el->rc_.load(std::memory_order_acquire); - if ((cur_rc & ep_mask) == 0) { - std::forward (out)(true); - return true; - } - auto nxt_rc = cur_rc & ~static_cast (wrapper->connected_id()); - if (el->rc_.compare_exchange_weak(cur_rc, nxt_rc, std::memory_order_release)) { - std::forward (out)((nxt_rc & ep_mask) == 0); - return true; - } - ipc::yield(k); - } - } -}; - -template <> -struct prod_cons_impl rc_ { 0 }; // read-counter - std::atomic f_ct_ { 0 }; // commit flag - }; - - alignas(cache_line_size) std::atomic epoch_ { 0 }; - - circ::u2_t cursor() const noexcept { - return ct_.load(std::memory_order_acquire); - } - - constexpr static rc_t inc_rc(rc_t rc) noexcept { - return (rc & ic_mask) | ((rc + ic_incr) & ~ic_mask); - } - - constexpr static rc_t inc_mask(rc_t rc) noexcept { - return inc_rc(rc) & ~rc_mask; - } - - template - bool push(W* wrapper, F&& f, E* elems) { - E* el; - circ::u2_t cur_ct; - rc_t epoch = epoch_.load(std::memory_order_acquire); - for (unsigned k = 0;;) { - circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed); - if (cc == 0) return false; // no reader - el = elems + circ::index_of(cur_ct = ct_.load(std::memory_order_relaxed)); - // check all consumers have finished reading this element - auto cur_rc = el->rc_.load(std::memory_order_relaxed); - circ::cc_t rem_cc = cur_rc & rc_mask; - if ((cc & rem_cc) && ((cur_rc & ~ep_mask) == epoch)) { - return false; // has not finished yet - } - else if (!rem_cc) { - auto cur_fl = el->f_ct_.load(std::memory_order_acquire); - if ((cur_fl != cur_ct) && cur_fl) { - return false; // full - } - } - // consider rem_cc to be 0 here - if (el->rc_.compare_exchange_weak( - cur_rc, inc_mask(epoch | (cur_rc & ep_mask)) | static_cast (cc), std::memory_order_relaxed) && - epoch_.compare_exchange_weak(epoch, epoch, std::memory_order_acq_rel)) { - break; - } - ipc::yield(k); - } - // only one thread/process would touch here at one time - ct_.store(cur_ct + 1, std::memory_order_release); - std::forward (f)(&(el->data_)); - // set flag & try update wt - el->f_ct_.store(~static_cast (cur_ct), std::memory_order_release); - return true; - } - - template - bool force_push(W* wrapper, F&& f, E* elems) { - E* el; - circ::u2_t cur_ct; - rc_t epoch = epoch_.fetch_add(ep_incr, std::memory_order_release) + ep_incr; - for (unsigned k = 0;;) { - circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed); - if (cc == 0) return false; // no reader - el = elems + circ::index_of(cur_ct = ct_.load(std::memory_order_relaxed)); - // check all consumers have finished reading this element - auto cur_rc = el->rc_.load(std::memory_order_acquire); - circ::cc_t rem_cc = cur_rc & rc_mask; - if (cc & rem_cc) { - ipc::log("force_push: k = %u, cc = %u, rem_cc = %u\n", k, cc, rem_cc); - cc = wrapper->elems()->disconnect_receiver(rem_cc); // disconnect all invalid readers - if (cc == 0) return false; // no reader - } - // just compare & exchange - if (el->rc_.compare_exchange_weak( - cur_rc, inc_mask(epoch | (cur_rc & ep_mask)) | static_cast (cc), std::memory_order_relaxed)) { - if (epoch == epoch_.load(std::memory_order_acquire)) { - break; - } - else if (push(wrapper, std::forward (f), elems)) { - return true; - } - epoch = epoch_.fetch_add(ep_incr, std::memory_order_release) + ep_incr; - } - ipc::yield(k); - } - // only one thread/process would touch here at one time - ct_.store(cur_ct + 1, std::memory_order_release); - std::forward (f)(&(el->data_)); - // set flag & try update wt - el->f_ct_.store(~static_cast (cur_ct), std::memory_order_release); - return true; - } - - template - bool pop(W* wrapper, circ::u2_t& cur, F&& f, R&& out, E(& elems)[N]) { - auto* el = elems + circ::index_of(cur); - auto cur_fl = el->f_ct_.load(std::memory_order_acquire); - if (cur_fl != ~static_cast (cur)) { - return false; // empty - } - ++cur; - std::forward (f)(&(el->data_)); - for (unsigned k = 0;;) { - auto cur_rc = el->rc_.load(std::memory_order_acquire); - if ((cur_rc & rc_mask) == 0) { - std::forward (out)(true); - el->f_ct_.store(cur + N - 1, std::memory_order_release); - return true; - } - auto nxt_rc = inc_rc(cur_rc) & ~static_cast (wrapper->connected_id()); - bool last_one = false; - if ((last_one = (nxt_rc & rc_mask) == 0)) { - el->f_ct_.store(cur + N - 1, std::memory_order_release); - } - if (el->rc_.compare_exchange_weak(cur_rc, nxt_rc, std::memory_order_release)) { - std::forward (out)(last_one); - return true; - } - ipc::yield(k); - } - } -}; - -} // namespace ipc diff --git a/spaces/haoheliu/AudioLDM_48K_Text-to-HiFiAudio_Generation/app.py b/spaces/haoheliu/AudioLDM_48K_Text-to-HiFiAudio_Generation/app.py deleted file mode 100644 index a5cd6b4fd73be2bb1a170f6e2ce753c170d52cad..0000000000000000000000000000000000000000 --- a/spaces/haoheliu/AudioLDM_48K_Text-to-HiFiAudio_Generation/app.py +++ /dev/null @@ -1,358 +0,0 @@ -from sys import maxsize -from huggingface_hub import hf_hub_download -import torch -import os - -import gradio as gr -from audioldm2 import text_to_audio, build_model -from share_btn import community_icon_html, loading_icon_html, share_js - -os.environ["TOKENIZERS_PARALLELISM"] = "true" - -# default_checkpoint="audioldm2-full" -default_checkpoint="audioldm_48k" -audioldm = None -current_model_name = None - -def text2audio( - text, - duration, - guidance_scale, - random_seed, - n_candidates, - model_name=default_checkpoint, -): - global audioldm, current_model_name - torch.set_float32_matmul_precision("high") - - if audioldm is None or model_name != current_model_name: - audioldm = build_model(model_name=model_name) - current_model_name = model_name - # audioldm = torch.compile(audioldm) - # print(text, length, guidance_scale) - if("48k" in model_name): - latent_t_per_second=12.8 - sample_rate=48000 - else: - latent_t_per_second=25.6 - sample_rate=16000 - - waveform = text_to_audio( - latent_diffusion=audioldm, - text=text, - seed=random_seed, - duration=duration, - guidance_scale=guidance_scale, - n_candidate_gen_per_text=int(n_candidates), - latent_t_per_second=latent_t_per_second, - ) # [bs, 1, samples] - waveform = [ - gr.make_waveform((sample_rate, wave[0]), bg_image="bg.png") for wave in waveform - ] - # waveform = [(16000, np.random.randn(16000)), (16000, np.random.randn(16000))] - if len(waveform) == 1: - waveform = waveform[0] - return waveform - -text2audio("Birds singing sweetly in a blooming garden.", 10, 3.5, 45, 3, default_checkpoint) - -css = """ - a { - color: inherit; - text-decoration: underline; - } - .gradio-container { - font-family: 'IBM Plex Sans', sans-serif; - } - .gr-button { - color: white; - border-color: #000000; - background: #000000; - } - input[type='range'] { - accent-color: #000000; - } - .dark input[type='range'] { - accent-color: #dfdfdf; - } - .container { - max-width: 730px; - margin: auto; - padding-top: 1.5rem; - } - #gallery { - min-height: 22rem; - margin-bottom: 15px; - margin-left: auto; - margin-right: auto; - border-bottom-right-radius: .5rem !important; - border-bottom-left-radius: .5rem !important; - } - #gallery>div>.h-full { - min-height: 20rem; - } - .details:hover { - text-decoration: underline; - } - .gr-button { - white-space: nowrap; - } - .gr-button:focus { - border-color: rgb(147 197 253 / var(--tw-border-opacity)); - outline: none; - box-shadow: var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow, 0 0 #0000); - --tw-border-opacity: 1; - --tw-ring-offset-shadow: var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color); - --tw-ring-shadow: var(--tw-ring-inset) 0 0 0 calc(3px var(--tw-ring-offset-width)) var(--tw-ring-color); - --tw-ring-color: rgb(191 219 254 / var(--tw-ring-opacity)); - --tw-ring-opacity: .5; - } - #advanced-btn { - font-size: .7rem !important; - line-height: 19px; - margin-top: 12px; - margin-bottom: 12px; - padding: 2px 8px; - border-radius: 14px !important; - } - #advanced-options { - margin-bottom: 20px; - } - .footer { - margin-bottom: 45px; - margin-top: 35px; - text-align: center; - border-bottom: 1px solid #e5e5e5; - } - .footer>p { - font-size: .8rem; - display: inline-block; - padding: 0 10px; - transform: translateY(10px); - background: white; - } - .dark .footer { - border-color: #303030; - } - .dark .footer>p { - background: #0b0f19; - } - .acknowledgments h4{ - margin: 1.25em 0 .25em 0; - font-weight: bold; - font-size: 115%; - } - #container-advanced-btns{ - display: flex; - flex-wrap: wrap; - justify-content: space-between; - align-items: center; - } - .animate-spin { - animation: spin 1s linear infinite; - } - @keyframes spin { - from { - transform: rotate(0deg); - } - to { - transform: rotate(360deg); - } - } - #share-btn-container { - display: flex; padding-left: 0.5rem !important; padding-right: 0.5rem !important; background-color: #000000; justify-content: center; align-items: center; border-radius: 9999px !important; width: 13rem; - margin-top: 10px; - margin-left: auto; - } - #share-btn { - all: initial; color: #ffffff;font-weight: 600; cursor:pointer; font-family: 'IBM Plex Sans', sans-serif; margin-left: 0.5rem !important; padding-top: 0.25rem !important; padding-bottom: 0.25rem !important;right:0; - } - #share-btn * { - all: unset; - } - #share-btn-container div:nth-child(-n+2){ - width: auto !important; - min-height: 0px !important; - } - #share-btn-container .wrap { - display: none !important; - } - .gr-form{ - flex: 1 1 50%; border-top-right-radius: 0; border-bottom-right-radius: 0; - } - #prompt-container{ - gap: 0; - } - #generated_id{ - min-height: 700px - } - #setting_id{ - margin-bottom: 12px; - text-align: center; - font-weight: 900; - } -""" -iface = gr.Blocks(css=css) - -with iface: - gr.HTML( - """ - -- """ - ) - gr.HTML( - """ --- -- 48kHz AudioLDM: Generating High-Fidelity Audio and Music with Text -
-For faster inference without waiting in queue, you may duplicate the space and upgrade to GPU in settings. -
- """ - ) - with gr.Group(): - with gr.Box(): - ############# Input - textbox = gr.Textbox( - value="A forest of wind chimes singing a soothing melody in the breeze.", - max_lines=1, - label="Input your text here. If the output is not good enough, switching to a different seed will help.", - elem_id="prompt-in", - ) - - with gr.Accordion("Click to modify detailed configurations", open=False): - seed = gr.Number( - value=45, - label="Change this value (any integer number) will lead to a different generation result.", - ) - duration = gr.Slider( - 5, 15, value=10, step=2.5, label="Duration (seconds)" - ) - guidance_scale = gr.Slider( - 0, - 6, - value=3.5, - step=0.5, - label="Guidance scale (Large => better quality and relavancy to text; Small => better diversity)", - ) - n_candidates = gr.Slider( - 1, - 3, - value=3, - step=1, - label="Automatic quality control. This number control the number of candidates (e.g., generate three audios and choose the best to show you). A Larger value usually lead to better quality with heavier computation", - ) - model_name = gr.Dropdown( - ["audioldm_48k", "audioldm_crossattn_flant5", "audioldm2-full"], value="audioldm_48k", - ) - ############# Output - # outputs=gr.Audio(label="Output", type="numpy") - outputs = gr.Video(label="Output", elem_id="output-video") - - # with gr.Group(elem_id="container-advanced-btns"): - # # advanced_button = gr.Button("Advanced options", elem_id="advanced-btn") - # with gr.Group(elem_id="share-btn-container"): - # community_icon = gr.HTML(community_icon_html, visible=False) - # loading_icon = gr.HTML(loading_icon_html, visible=False) - # share_button = gr.Button("Share to community", elem_id="share-btn", visible=False) - # outputs=[gr.Audio(label="Output", type="numpy"), gr.Audio(label="Output", type="numpy")] - btn = gr.Button("Submit").style(full_width=True) - - with gr.Group(elem_id="share-btn-container", visible=False): - community_icon = gr.HTML(community_icon_html) - loading_icon = gr.HTML(loading_icon_html) - share_button = gr.Button("Share to community", elem_id="share-btn") - - # btn.click(text2audio, inputs=[ - # textbox, duration, guidance_scale, seed, n_candidates, model_name], outputs=[outputs]) - btn.click( - text2audio, - inputs=[textbox, duration, guidance_scale, seed, n_candidates], - outputs=[outputs], - api_name="text2audio", - ) - - share_button.click(None, [], [], _js=share_js) - gr.HTML( - """ - - """ - ) - gr.Examples( - [ - [ - "Birds singing sweetly in a blooming garden.", - 10, - 3.5, - 45, - 3, - default_checkpoint, - ], - [ - "A modern synthesizer creating futuristic soundscapes.", - 10, - 3.5, - 45, - 3, - default_checkpoint, - ], - [ - "The vibrant beat of Brazilian samba drums.", - 10, - 3.5, - 45, - 3, - default_checkpoint, - ], - ], - fn=text2audio, - inputs=[textbox, duration, guidance_scale, seed, n_candidates, model_name], - # inputs=[textbox, guidance_scale, seed, n_candidates], - outputs=[outputs], - cache_examples=True, - ) - gr.HTML( - """ -
- --- """ - ) - - with gr.Accordion("Additional information", open=False): - gr.HTML( - """ -Essential Tricks for Enhancing the Quality of Your Generated Audio
-1. Try to use more adjectives to describe your sound. For example: "A man is speaking clearly and slowly in a large room" is better than "A man is speaking". This can make sure AudioLDM 2 understands what you want.
-2. Try to use different random seeds, which can affect the generation quality significantly sometimes.
-3. It's better to use general terms like 'man' or 'woman' instead of specific names for individuals or abstract objects that humans may not be familiar with, such as 'mummy'.
--- """ - ) -#We build the model with data from AudioSet, Freesound and BBC Sound Effect library. We share this demo based on the UK copyright exception of data for academic research.
-This demo is strictly for research demo purpose only. For commercial use please contact us.
- -iface.queue(max_size=20) -iface.launch(debug=True) -# iface.launch(debug=True, share=True) diff --git a/spaces/harshvardhansb/ObjectDetection/public/index.html b/spaces/harshvardhansb/ObjectDetection/public/index.html deleted file mode 100644 index a8c1d6b197c9b7c0b7fef67e0ac7f071ca028933..0000000000000000000000000000000000000000 --- a/spaces/harshvardhansb/ObjectDetection/public/index.html +++ /dev/null @@ -1,23 +0,0 @@ - - - - - - - - - - - - -Object Detection - - - - - - - diff --git a/spaces/hasibzunair/fifa-tryon-demo/Self-Correction-Human-Parsing-for-ACGPN/mhp_extension/detectron2/projects/DensePose/tests/test_setup.py b/spaces/hasibzunair/fifa-tryon-demo/Self-Correction-Human-Parsing-for-ACGPN/mhp_extension/detectron2/projects/DensePose/tests/test_setup.py deleted file mode 100644 index 96827f14b3a71d571c2109791233b5bcf7ef35f8..0000000000000000000000000000000000000000 --- a/spaces/hasibzunair/fifa-tryon-demo/Self-Correction-Human-Parsing-for-ACGPN/mhp_extension/detectron2/projects/DensePose/tests/test_setup.py +++ /dev/null @@ -1,30 +0,0 @@ -# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. - -import unittest - -from .common import ( - get_config_files, - get_evolution_config_files, - get_quick_schedules_config_files, - setup, -) - - -class TestSetup(unittest.TestCase): - def _test_setup(self, config_file): - setup(config_file) - - def test_setup_configs(self): - config_files = get_config_files() - for config_file in config_files: - self._test_setup(config_file) - - def test_setup_evolution_configs(self): - config_files = get_evolution_config_files() - for config_file in config_files: - self._test_setup(config_file) - - def test_setup_quick_schedules_configs(self): - config_files = get_quick_schedules_config_files() - for config_file in config_files: - self._test_setup(config_file) diff --git a/spaces/hf4h/bio-chem-foundation-models/model_list.py b/spaces/hf4h/bio-chem-foundation-models/model_list.py deleted file mode 100644 index 886991b59a1049d2cfbd3ba35a54966480c4ee71..0000000000000000000000000000000000000000 --- a/spaces/hf4h/bio-chem-foundation-models/model_list.py +++ /dev/null @@ -1,106 +0,0 @@ -from __future__ import annotations - -import numpy as np -import pandas as pd -import requests -from huggingface_hub.hf_api import SpaceInfo - -url = 'https://docs.google.com/spreadsheets/d/1XH7Jo3LXXfbSJ14z-QrSIQs21ArJMiV6_hMSAwY85PU/edit#gid=0' -csv_url = url.replace('/edit#gid=', '/export?format=csv&gid=') - -class ModelList: - def __init__(self): - self.table = pd.read_csv(csv_url) - self._preprocess_table() - - self.table_header = ''' -- ''' - - def _preprocess_table(self) -> None: - self.table['name_lowercase'] = self.table.name.str.lower() - self.table['year'] = self.table['year'].apply(str) - - rows = [] - for row in self.table.itertuples(): - paper = f'Paper' if isinstance( - row.paper, str) else '' - github = f'GitHub' if isinstance( - row.github, str) else '' - hf_model = f'Hub Model' if isinstance( - row.hub, str) else '' - other_model = f'Other Weights' if isinstance( - row.other, str) else '' - data_type = f'{row.data_type}' if isinstance( - row.data_type, str) else '' - base_model = f'{row.base_model}' if isinstance( - row.base_model, str) else '' - year = f'{row.year}' if isinstance( - row.year, str) else '' - row = f''' -Model Name -Type -Year -Paper -Code on Github -Weights on 🤗 -Other Weights -- ''' - rows.append(row) - self.table['html_table_content'] = rows - - def render(self, search_query: str, - case_sensitive: bool, - filter_names: list[str], - data_types: list[str], - years: list[str], - #model_types: list[str] - ) -> tuple[int, str]: - df = self.table - if search_query: - if case_sensitive: - df = df[df.name.str.contains(search_query)] - else: - df = df[df.name_lowercase.str.contains(search_query.lower())] - has_paper = 'Paper' in filter_names - has_github = 'Code' in filter_names - has_model = 'Model Weights' in filter_names - df = self.filter_table(df, has_paper, has_github, has_model, data_types, years) - #df = self.filter_table(df, has_paper, has_github, has_model, data_types, model_types) - return len(df), self.to_html(df, self.table_header) - - @staticmethod - def filter_table(df: pd.DataFrame, has_paper: bool, has_github: bool, - has_model: bool, - data_types: list[str], - years: list[str], - #model_types: list[str] - ) -> pd.DataFrame: - if has_paper: - df = df[~df.paper.isna()] - if has_github: - df = df[~df.github.isna()] - if has_model: - df = df[~df.hub.isna() | ~df.other.isna()] - df = df[df.data_type.isin(set(data_types))] - #df = df[df.base_model.isin(set(model_types))] - df = df[df.year.isin(set(years))] - return df - - @staticmethod - def to_html(df: pd.DataFrame, table_header: str) -> str: - table_data = ''.join(df.html_table_content) - html = f''' -{row.name} -{data_type} -{year} -{paper} -{github} -{hf_model} -{other_model} -- {table_header} - {table_data} -
''' - return html \ No newline at end of file diff --git a/spaces/hylee/photo2cartoon/p2c/utils/face_seg.py b/spaces/hylee/photo2cartoon/p2c/utils/face_seg.py deleted file mode 100644 index 4938ccebbb7e55f959889c1bf3bc2ca7dac7ffe6..0000000000000000000000000000000000000000 --- a/spaces/hylee/photo2cartoon/p2c/utils/face_seg.py +++ /dev/null @@ -1,44 +0,0 @@ -import os -import cv2 -import numpy as np -import tensorflow as tf -from tensorflow.python.platform import gfile - - -curPath = os.path.abspath(os.path.dirname(__file__)) - - -class FaceSeg: - def __init__(self, model_path=os.path.join(curPath, 'seg_model_384.pb')): - config = tf.compat.v1.ConfigProto() - config.gpu_options.allow_growth = True - self._graph = tf.Graph() - self._sess = tf.compat.v1.Session(config=config, graph=self._graph) - - self.pb_file_path = model_path - self._restore_from_pb() - self.input_op = self._sess.graph.get_tensor_by_name('input_1:0') - self.output_op = self._sess.graph.get_tensor_by_name('sigmoid/Sigmoid:0') - - def _restore_from_pb(self): - with self._sess.as_default(): - with self._graph.as_default(): - with gfile.FastGFile(self.pb_file_path, 'rb') as f: - graph_def = tf.compat.v1.GraphDef() - graph_def.ParseFromString(f.read()) - tf.import_graph_def(graph_def, name='') - - def input_transform(self, image): - image = cv2.resize(image, (384, 384), interpolation=cv2.INTER_AREA) - image_input = (image / 255.)[np.newaxis, :, :, :] - return image_input - - def output_transform(self, output, shape): - output = cv2.resize(output, (shape[1], shape[0])) - image_output = (output * 255).astype(np.uint8) - return image_output - - def get_mask(self, image): - image_input = self.input_transform(image) - output = self._sess.run(self.output_op, feed_dict={self.input_op: image_input})[0] - return self.output_transform(output, shape=image.shape[:2]) diff --git a/spaces/hyxue/HiFiFace-inference-demo/Deep3DFaceRecon_pytorch/data/image_folder.py b/spaces/hyxue/HiFiFace-inference-demo/Deep3DFaceRecon_pytorch/data/image_folder.py deleted file mode 100644 index 0a02dfe06948ddb90a76667d538f7e3ea47a33e8..0000000000000000000000000000000000000000 --- a/spaces/hyxue/HiFiFace-inference-demo/Deep3DFaceRecon_pytorch/data/image_folder.py +++ /dev/null @@ -1,77 +0,0 @@ -"""A modified image folder class - -We modify the official PyTorch image folder (https://github.com/pytorch/vision/blob/master/torchvision/datasets/folder.py) -so that this class can load images from both current directory and its subdirectories. -""" -import os.path - -import numpy as np -import torch.utils.data as data -from PIL import Image - -IMG_EXTENSIONS = [ - ".jpg", - ".JPG", - ".jpeg", - ".JPEG", - ".png", - ".PNG", - ".ppm", - ".PPM", - ".bmp", - ".BMP", - ".tif", - ".TIF", - ".tiff", - ".TIFF", -] - - -def is_image_file(filename): - return any(filename.endswith(extension) for extension in IMG_EXTENSIONS) - - -def make_dataset(dir, max_dataset_size=float("inf")): - images = [] - assert os.path.isdir(dir) or os.path.islink(dir), "%s is not a valid directory" % dir - - for root, _, fnames in sorted(os.walk(dir, followlinks=True)): - for fname in fnames: - if is_image_file(fname): - path = os.path.join(root, fname) - images.append(path) - return images[: min(max_dataset_size, len(images))] - - -def default_loader(path): - return Image.open(path).convert("RGB") - - -class ImageFolder(data.Dataset): - def __init__(self, root, transform=None, return_paths=False, loader=default_loader): - imgs = make_dataset(root) - if len(imgs) == 0: - raise ( - RuntimeError( - "Found 0 images in: " + root + "\n" "Supported image extensions are: " + ",".join(IMG_EXTENSIONS) - ) - ) - - self.root = root - self.imgs = imgs - self.transform = transform - self.return_paths = return_paths - self.loader = loader - - def __getitem__(self, index): - path = self.imgs[index] - img = self.loader(path) - if self.transform is not None: - img = self.transform(img) - if self.return_paths: - return img, path - else: - return img - - def __len__(self): - return len(self.imgs) diff --git a/spaces/ibvhim/Gradio-Apps/Chatbot/app.py b/spaces/ibvhim/Gradio-Apps/Chatbot/app.py deleted file mode 100644 index 98ab8f8bb570d27ff5890317bd431fe00a1379c1..0000000000000000000000000000000000000000 --- a/spaces/ibvhim/Gradio-Apps/Chatbot/app.py +++ /dev/null @@ -1,35 +0,0 @@ -import torch -from transformers import AutoModelForCausalLM, AutoTokenizer - -tokenizer = AutoTokenizer.from_pretrained("microsoft/DialoGPT-medium") -model = AutoModelForCausalLM.from_pretrained("microsoft/DialoGPT-medium") - - -def predict(input, history=[]): - # tokenize the new input sentence - new_user_input_ids = tokenizer.encode(input + tokenizer.eos_token, return_tensors='pt') - - # append the new user input tokens to the chat history - bot_input_ids = torch.cat([torch.LongTensor(history), new_user_input_ids], dim=-1) - - # generate a response - history = model.generate(bot_input_ids, max_length=1000, pad_token_id=tokenizer.eos_token_id).tolist() - - # convert the tokens to text, and then split the responses into the right format - response = tokenizer.decode(history[0]).split("<|endoftext|>") - response = [(response[i], response[i + 1]) for i in range(0, len(response) - 1, 2)] # convert to tuples of list - return response, history - - -import gradio as gr - -interface = gr.Interface( - fn=predict, - theme="default", - css=".footer {display:none !important}", - inputs=["text", "state"], - outputs=["chatbot", "state"], -) - -if __name__ == '__main__': - interface.launch() diff --git a/spaces/imperialwool/funapi/templates/forbidden.html b/spaces/imperialwool/funapi/templates/forbidden.html deleted file mode 100644 index 3d48e67e9ae17434267c83438d3d2cb491779787..0000000000000000000000000000000000000000 --- a/spaces/imperialwool/funapi/templates/forbidden.html +++ /dev/null @@ -1,3 +0,0 @@ -403 Forbidden - -\ No newline at end of file diff --git a/spaces/inamXcontru/PoeticTTS/Delcam PowerMill 2013 Download Learn How to Use PowerMill for CNC Machining and CAM.md b/spaces/inamXcontru/PoeticTTS/Delcam PowerMill 2013 Download Learn How to Use PowerMill for CNC Machining and CAM.md deleted file mode 100644 index 0a41799a7b57af4460c527bed6549982252299b8..0000000000000000000000000000000000000000 --- a/spaces/inamXcontru/PoeticTTS/Delcam PowerMill 2013 Download Learn How to Use PowerMill for CNC Machining and CAM.md +++ /dev/null @@ -1,6 +0,0 @@ -403
Forbidden
delcampowermill2013download
DOWNLOAD 🆓 https://gohhs.com/2uz46t
-
- aaccfb2cb3
-
-
- diff --git a/spaces/innnky/nyaru-svc2.0/data_utils.py b/spaces/innnky/nyaru-svc2.0/data_utils.py deleted file mode 100644 index e125a0637908e1284208b80e4b16a50996a136be..0000000000000000000000000000000000000000 --- a/spaces/innnky/nyaru-svc2.0/data_utils.py +++ /dev/null @@ -1,413 +0,0 @@ -import time -import os -import random -import numpy as np -import torch -import torch.utils.data -import numpy as np -import commons -from mel_processing import spectrogram_torch -from utils import load_wav_to_torch, load_filepaths_and_text -from text import text_to_sequence, cleaned_text_to_sequence - - -def dropout1d(myarray, ratio=0.5): - indices = np.random.choice(np.arange(myarray.size), replace=False, - size=int(myarray.size * ratio)) - myarray[indices] = 0 - return myarray - - -class TextAudioLoader(torch.utils.data.Dataset): - """ - 1) loads audio, text pairs - 2) normalizes text and converts them to sequences of integers - 3) computes spectrograms from audio files. - """ - - def __init__(self, audiopaths_and_text, hparams): - self.audiopaths_and_text = load_filepaths_and_text(audiopaths_and_text) - self.text_cleaners = hparams.text_cleaners - self.max_wav_value = hparams.max_wav_value - self.sampling_rate = hparams.sampling_rate - self.filter_length = hparams.filter_length - self.hop_length = hparams.hop_length - self.win_length = hparams.win_length - self.sampling_rate = hparams.sampling_rate - - self.cleaned_text = getattr(hparams, "cleaned_text", False) - - self.add_blank = hparams.add_blank - self.min_text_len = getattr(hparams, "min_text_len", 1) - self.max_text_len = getattr(hparams, "max_text_len", 190) - - random.seed(1234) - random.shuffle(self.audiopaths_and_text) - self._filter() - - def _filter(self): - """ - Filter text & store spec lengths - """ - # Store spectrogram lengths for Bucketing - # wav_length ~= file_size / (wav_channels * Bytes per dim) = file_size / (1 * 2) - # spec_length = wav_length // hop_length - lengths = [] - for audiopath, text, pitch in self.audiopaths_and_text: - lengths.append(os.path.getsize(audiopath) // (2 * self.hop_length)) - self.lengths = lengths - - def get_audio_text_pair(self, audiopath_and_text): - # separate filename and text - audiopath, text, pitch = audiopath_and_text[0], audiopath_and_text[1],audiopath_and_text[2] - text = self.get_text(text) - spec, wav = self.get_audio(audiopath) - pitch = self.get_pitch(pitch) - return (text, spec, wav, pitch) - - def get_pitch(self, pitch): - - return torch.LongTensor(np.load(pitch)) - - def get_audio(self, filename): - audio, sampling_rate = load_wav_to_torch(filename) - if sampling_rate != self.sampling_rate: - raise ValueError("{} {} SR doesn't match target {} SR".format( - sampling_rate, self.sampling_rate)) - audio_norm = audio / self.max_wav_value - audio_norm = audio_norm.unsqueeze(0) - spec_filename = filename.replace(".wav", ".spec.pt") - if os.path.exists(spec_filename): - spec = torch.load(spec_filename) - else: - spec = spectrogram_torch(audio_norm, self.filter_length, - self.sampling_rate, self.hop_length, self.win_length, - center=False) - spec = torch.squeeze(spec, 0) - torch.save(spec, spec_filename) - return spec, audio_norm - - def get_text(self, text): - soft = np.load(text) - text_norm = torch.FloatTensor(soft) - return text_norm - - def __getitem__(self, index): - return self.get_audio_text_pair(self.audiopaths_and_text[index]) - - def __len__(self): - return len(self.audiopaths_and_text) - - -class TextAudioCollate(): - """ Zero-pads model inputs and targets - """ - - def __init__(self, return_ids=False): - self.return_ids = return_ids - - def __call__(self, batch): - """Collate's training batch from normalized text and aduio - PARAMS - ------ - batch: [text_normalized, spec_normalized, wav_normalized] - """ - # Right zero-pad all one-hot text sequences to max input length - _, ids_sorted_decreasing = torch.sort( - torch.LongTensor([x[1].size(1) for x in batch]), - dim=0, descending=True) - - max_text_len = max([len(x[0]) for x in batch]) - max_spec_len = max([x[1].size(1) for x in batch]) - max_wav_len = max([x[2].size(1) for x in batch]) - max_pitch_len = max([x[3].shape[0] for x in batch]) - # print(batch) - - - text_lengths = torch.LongTensor(len(batch)) - spec_lengths = torch.LongTensor(len(batch)) - wav_lengths = torch.LongTensor(len(batch)) - - text_padded = torch.FloatTensor(len(batch), max_text_len, 256) - spec_padded = torch.FloatTensor(len(batch), batch[0][1].size(0), max_spec_len) - wav_padded = torch.FloatTensor(len(batch), 1, max_wav_len) - pitch_padded = torch.LongTensor(len(batch), max_pitch_len) - - text_padded.zero_() - spec_padded.zero_() - wav_padded.zero_() - pitch_padded.zero_() - for i in range(len(ids_sorted_decreasing)): - row = batch[ids_sorted_decreasing[i]] - - text = row[0] - text_padded[i, :text.size(0), :] = text - text_lengths[i] = text.size(0) - - spec = row[1] - spec_padded[i, :, :spec.size(1)] = spec - spec_lengths[i] = spec.size(1) - - wav = row[2] - wav_padded[i, :, :wav.size(1)] = wav - wav_lengths[i] = wav.size(1) - - pitch = row[3] - pitch_padded[i, :pitch.size(0)] = pitch - - if self.return_ids: - return text_padded, text_lengths, spec_padded, spec_lengths, wav_padded, wav_lengths, ids_sorted_decreasing, pitch_padded - return text_padded, text_lengths, spec_padded, spec_lengths, wav_padded, wav_lengths, pitch_padded - - -"""Multi speaker version""" - - -class TextAudioSpeakerLoader(torch.utils.data.Dataset): - """ - 1) loads audio, speaker_id, text pairs - 2) normalizes text and converts them to sequences of integers - 3) computes spectrograms from audio files. - """ - - def __init__(self, audiopaths_sid_text, hparams): - self.audiopaths_sid_text = load_filepaths_and_text(audiopaths_sid_text) - self.text_cleaners = hparams.text_cleaners - self.max_wav_value = hparams.max_wav_value - self.sampling_rate = hparams.sampling_rate - self.filter_length = hparams.filter_length - self.hop_length = hparams.hop_length - self.win_length = hparams.win_length - self.sampling_rate = hparams.sampling_rate - - self.cleaned_text = getattr(hparams, "cleaned_text", False) - - self.add_blank = hparams.add_blank - self.min_text_len = getattr(hparams, "min_text_len", 1) - self.max_text_len = getattr(hparams, "max_text_len", 190) - - random.seed(1234) - random.shuffle(self.audiopaths_sid_text) - self._filter() - - def _filter(self): - """ - Filter text & store spec lengths - """ - # Store spectrogram lengths for Bucketing - # wav_length ~= file_size / (wav_channels * Bytes per dim) = file_size / (1 * 2) - # spec_length = wav_length // hop_length - - lengths = [] - for audiopath, sid, text, pitch in self.audiopaths_sid_text: - lengths.append(os.path.getsize(audiopath) // (2 * self.hop_length)) - self.lengths = lengths - - def get_audio_text_speaker_pair(self, audiopath_sid_text): - # separate filename, speaker_id and text - audiopath, sid, text, pitch = audiopath_sid_text[0], audiopath_sid_text[1], audiopath_sid_text[2], audiopath_sid_text[3] - text = self.get_text(text) - spec, wav = self.get_audio(audiopath) - sid = self.get_sid(sid) - pitch = self.get_pitch(pitch) - - return (text, spec, wav, pitch, sid) - - def get_audio(self, filename): - audio, sampling_rate = load_wav_to_torch(filename) - if sampling_rate != self.sampling_rate: - raise ValueError("{} {} SR doesn't match target {} SR".format( - sampling_rate, self.sampling_rate)) - audio_norm = audio / self.max_wav_value - audio_norm = audio_norm.unsqueeze(0) - spec_filename = filename.replace(".wav", ".spec.pt") - if os.path.exists(spec_filename): - spec = torch.load(spec_filename) - else: - spec = spectrogram_torch(audio_norm, self.filter_length, - self.sampling_rate, self.hop_length, self.win_length, - center=False) - spec = torch.squeeze(spec, 0) - torch.save(spec, spec_filename) - return spec, audio_norm - - def get_text(self, text): - soft = np.load(text) - text_norm = torch.FloatTensor(soft) - return text_norm - - def get_pitch(self, pitch): - return torch.LongTensor(np.load(pitch)) - - def get_sid(self, sid): - sid = torch.LongTensor([int(sid)]) - return sid - - def __getitem__(self, index): - return self.get_audio_text_speaker_pair(self.audiopaths_sid_text[index]) - - def __len__(self): - return len(self.audiopaths_sid_text) - - -class TextAudioSpeakerCollate(): - """ Zero-pads model inputs and targets - """ - - def __init__(self, return_ids=False): - self.return_ids = return_ids - - def __call__(self, batch): - """Collate's training batch from normalized text, audio and speaker identities - PARAMS - ------ - batch: [text_normalized, spec_normalized, wav_normalized, sid] - """ - # Right zero-pad all one-hot text sequences to max input length - _, ids_sorted_decreasing = torch.sort( - torch.LongTensor([x[1].size(1) for x in batch]), - dim=0, descending=True) - - max_text_len = max([len(x[0]) for x in batch]) - max_spec_len = max([x[1].size(1) for x in batch]) - max_wav_len = max([x[2].size(1) for x in batch]) - max_pitch_len = max([x[3].shape[0] for x in batch]) - - text_lengths = torch.LongTensor(len(batch)) - spec_lengths = torch.LongTensor(len(batch)) - wav_lengths = torch.LongTensor(len(batch)) - sid = torch.LongTensor(len(batch)) - - text_padded = torch.FloatTensor(len(batch), max_text_len, 256) - spec_padded = torch.FloatTensor(len(batch), batch[0][1].size(0), max_spec_len) - wav_padded = torch.FloatTensor(len(batch), 1, max_wav_len) - pitch_padded = torch.LongTensor(len(batch), max_pitch_len) - - text_padded.zero_() - spec_padded.zero_() - wav_padded.zero_() - pitch_padded.zero_() - - for i in range(len(ids_sorted_decreasing)): - row = batch[ids_sorted_decreasing[i]] - - text = row[0] - text_padded[i, :text.size(0)] = text - text_lengths[i] = text.size(0) - - spec = row[1] - spec_padded[i, :, :spec.size(1)] = spec - spec_lengths[i] = spec.size(1) - - wav = row[2] - wav_padded[i, :, :wav.size(1)] = wav - wav_lengths[i] = wav.size(1) - - pitch = row[3] - pitch_padded[i, :pitch.size(0)] = pitch - - sid[i] = row[4] - - if self.return_ids: - return text_padded, text_lengths, spec_padded, spec_lengths, wav_padded, wav_lengths, pitch_padded, sid, ids_sorted_decreasing - return text_padded, text_lengths, spec_padded, spec_lengths, wav_padded, wav_lengths,pitch_padded , sid - - -class DistributedBucketSampler(torch.utils.data.distributed.DistributedSampler): - """ - Maintain similar input lengths in a batch. - Length groups are specified by boundaries. - Ex) boundaries = [b1, b2, b3] -> any batch is included either {x | b1 < length(x) <=b2} or {x | b2 < length(x) <= b3}. - - It removes samples which are not included in the boundaries. - Ex) boundaries = [b1, b2, b3] -> any x s.t. length(x) <= b1 or length(x) > b3 are discarded. - """ - - def __init__(self, dataset, batch_size, boundaries, num_replicas=None, rank=None, shuffle=True): - super().__init__(dataset, num_replicas=num_replicas, rank=rank, shuffle=shuffle) - self.lengths = dataset.lengths - self.batch_size = batch_size - self.boundaries = boundaries - - self.buckets, self.num_samples_per_bucket = self._create_buckets() - self.total_size = sum(self.num_samples_per_bucket) - self.num_samples = self.total_size // self.num_replicas - - def _create_buckets(self): - buckets = [[] for _ in range(len(self.boundaries) - 1)] - for i in range(len(self.lengths)): - length = self.lengths[i] - idx_bucket = self._bisect(length) - if idx_bucket != -1: - buckets[idx_bucket].append(i) - - for i in range(len(buckets) - 1, 0, -1): - if len(buckets[i]) == 0: - buckets.pop(i) - self.boundaries.pop(i + 1) - - num_samples_per_bucket = [] - for i in range(len(buckets)): - len_bucket = len(buckets[i]) - total_batch_size = self.num_replicas * self.batch_size - rem = (total_batch_size - (len_bucket % total_batch_size)) % total_batch_size - num_samples_per_bucket.append(len_bucket + rem) - return buckets, num_samples_per_bucket - - def __iter__(self): - # deterministically shuffle based on epoch - g = torch.Generator() - g.manual_seed(self.epoch) - - indices = [] - if self.shuffle: - for bucket in self.buckets: - indices.append(torch.randperm(len(bucket), generator=g).tolist()) - else: - for bucket in self.buckets: - indices.append(list(range(len(bucket)))) - - batches = [] - for i in range(len(self.buckets)): - bucket = self.buckets[i] - len_bucket = len(bucket) - ids_bucket = indices[i] - num_samples_bucket = self.num_samples_per_bucket[i] - - # add extra samples to make it evenly divisible - rem = num_samples_bucket - len_bucket - ids_bucket = ids_bucket + ids_bucket * (rem // len_bucket) + ids_bucket[:(rem % len_bucket)] - - # subsample - ids_bucket = ids_bucket[self.rank::self.num_replicas] - - # batching - for j in range(len(ids_bucket) // self.batch_size): - batch = [bucket[idx] for idx in ids_bucket[j * self.batch_size:(j + 1) * self.batch_size]] - batches.append(batch) - - if self.shuffle: - batch_ids = torch.randperm(len(batches), generator=g).tolist() - batches = [batches[i] for i in batch_ids] - self.batches = batches - - assert len(self.batches) * self.batch_size == self.num_samples - return iter(self.batches) - - def _bisect(self, x, lo=0, hi=None): - if hi is None: - hi = len(self.boundaries) - 1 - - if hi > lo: - mid = (hi + lo) // 2 - if self.boundaries[mid] < x and x <= self.boundaries[mid + 1]: - return mid - elif x <= self.boundaries[mid]: - return self._bisect(x, lo, mid) - else: - return self._bisect(x, mid + 1, hi) - else: - return -1 - - def __len__(self): - return self.num_samples // self.batch_size diff --git a/spaces/inplisQlawa/anything-midjourney-v4-1/License Key For Vivid Workshopdata Ati 12.1 !NEW!.md b/spaces/inplisQlawa/anything-midjourney-v4-1/License Key For Vivid Workshopdata Ati 12.1 !NEW!.md deleted file mode 100644 index 1528a1a2fffacf051c6784f328597698d9e8ecb3..0000000000000000000000000000000000000000 --- a/spaces/inplisQlawa/anything-midjourney-v4-1/License Key For Vivid Workshopdata Ati 12.1 !NEW!.md +++ /dev/null @@ -1,86 +0,0 @@ - -License Key for Vivid WorkshopData ATI 12.1
-If you are looking for a reliable and comprehensive software program for electrical motor diagnostics, repair and maintenance of European cars, you might want to consider Vivid WorkshopData ATI 12.1. This software provides you with up-to-date technical information, wiring diagrams, service schedules, fault codes and more. But how can you get a license key for Vivid WorkshopData ATI 12.1 and enjoy its full features? In this article, we will show you how to do that.
-What is Vivid WorkshopData ATI 12.1?
-Vivid WorkshopData ATI 12.1 is a software program that was developed by HaynesPro, a leading provider of automotive data solutions. It is designed to help professional mechanics and technicians with electrical motor diagnostics, repair and maintenance of European cars. It covers more than 25,000 models from over 80 vehicle manufacturers.
-license key for vivid workshopdata ati 12.1
Download File ››››› https://urlin.us/2uEvhF
-Some of the features of Vivid WorkshopData ATI 12.1 are:
--
-
- Easy-to-use interface with intuitive navigation -
- Comprehensive and up-to-date technical information -
- Wiring diagrams with component locations and colors -
- Service schedules with service indicators and reset procedures -
- Fault codes with descriptions and causes -
- Component testing and measuring procedures -
- Repair times and labor costs -
- Technical bulletins and recalls -
- Online updates and support -
How to get a license key for Vivid WorkshopData ATI 12.1?
-To use Vivid WorkshopData ATI 12.1, you need to have a valid license key that activates the software on your computer. There are two ways to get a license key for Vivid WorkshopData ATI 12.1: buying it from an authorized dealer or cracking it from a third-party source.
-The first option is to buy a license key from an authorized dealer of HaynesPro. This is the safest and most legal way to get a license key for Vivid WorkshopData ATI 12.1. You can find a list of authorized dealers on the official website of HaynesPro: https://www.haynespro.com/en/dealers/. You can also contact HaynesPro directly to request a quote or a demo: https://www.haynespro.com/en/contact/.
-The second option is to crack a license key from a third-party source. This is the riskiest and most illegal way to get a license key for Vivid WorkshopData ATI 12.1. You can find various websites that offer cracked license keys for Vivid WorkshopData ATI 12.1, such as https://pletfaydeasac.weebly.com/vivid-workshopdata-ati-121rar-crackrar.html or https://trello.com/c/17GxEICS/27-license-key-for-vivid-workshopdata-ati-121. However, these websites are not trustworthy and may contain viruses, malware or spyware that can harm your computer or steal your personal information. Moreover, cracking a license key is a violation of the intellectual property rights of HaynesPro and may result in legal consequences.
-Conclusion
-Vivid WorkshopData ATI 12.1 is a software program that provides comprehensive and up-to-date technical information for electrical motor diagnostics, repair and maintenance of European cars. To use it, you need to have a valid license key that activates the software on your computer. You can either buy a license key from an authorized dealer of HaynesPro or crack a license key from a third-party source. However, we strongly recommend the first option as it is safer, legal and ethical.
-What are the benefits of using Vivid WorkshopData ATI 12.1?
-Using Vivid WorkshopData ATI 12.1 can bring you many benefits as a professional mechanic or technician. Some of the benefits are:
- --
-
- You can save time and money by accessing accurate and updated technical information in one place. -
- You can improve your skills and knowledge by learning from the best practices and tips from experts. -
- You can increase your customer satisfaction and loyalty by providing high-quality service and repair. -
- You can boost your reputation and credibility by using a trusted and reputable software program. -
- You can enhance your productivity and efficiency by using a user-friendly and intuitive interface. -
How to install and activate Vivid WorkshopData ATI 12.1 with license key?
-To install and activate Vivid WorkshopData ATI 12.1 with license key, you need to follow these steps:
--
-
- Download the software program from the official website of HaynesPro or from an authorized dealer. -
- Extract the .rar file using a program like WinRAR or 7-Zip. -
- Run the setup.exe file and follow the instructions on the screen. -
- Enter the license key when prompted. You can find the license key in the email confirmation or in the package that you received. -
- Wait for the installation and activation process to complete. -
- Enjoy using Vivid WorkshopData ATI 12.1! -
Conclusion
-Vivid WorkshopData ATI 12.1 is a software program that provides comprehensive and up-to-date technical information for electrical motor diagnostics, repair and maintenance of European cars. To use it, you need to have a valid license key that activates the software on your computer. You can either buy a license key from an authorized dealer of HaynesPro or crack a license key from a third-party source. However, we strongly recommend the first option as it is safer, legal and ethical. Using Vivid WorkshopData ATI 12.1 can bring you many benefits as a professional mechanic or technician, such as saving time and money, improving your skills and knowledge, increasing your customer satisfaction and loyalty, boosting your reputation and credibility, and enhancing your productivity and efficiency.
-What are the alternatives to Vivid WorkshopData ATI 12.1?
-Vivid WorkshopData ATI 12.1 is not the only software program that offers technical information for electrical motor diagnostics, repair and maintenance of European cars. There are some alternatives that you can consider, such as:
--
-
- Autodata: Autodata is a software program that provides technical information for over 34,000 models from over 142 manufacturers. It covers service schedules, wiring diagrams, diagnostics, repair instructions, technical specifications and more. You can buy a license key from an authorized dealer or subscribe online: https://www.autodata-group.com/. -
- Alldata: Alldata is a software program that provides technical information for over 38,000 models from over 175 manufacturers. It covers service schedules, wiring diagrams, diagnostics, repair instructions, technical bulletins and more. You can buy a license key from an authorized dealer or subscribe online: https://www.alldata.com/. -
- Mitchell: Mitchell is a software program that provides technical information for over 30,000 models from over 80 manufacturers. It covers service schedules, wiring diagrams, diagnostics, repair instructions, labor times and more. You can buy a license key from an authorized dealer or subscribe online: https://www.mitchell.com/. -
How to choose the best software program for your needs?
-To choose the best software program for your needs, you need to consider some factors, such as:
--
-
- Your budget: Different software programs have different prices and payment options. You need to compare the costs and benefits of each software program and choose the one that fits your budget. -
- Your preferences: Different software programs have different features and interfaces. You need to test each software program and choose the one that suits your preferences and style. -
- Your requirements: Different software programs have different coverage and quality of technical information. You need to check each software program and choose the one that meets your requirements and expectations. -
Conclusion
-Vivid WorkshopData ATI 12.1 is a software program that provides comprehensive and up-to-date technical information for electrical motor diagnostics, repair and maintenance of European cars. To use it, you need to have a valid license key that activates the software on your computer. You can either buy a license key from an authorized dealer of HaynesPro or crack a license key from a third-party source. However, we strongly recommend the first option as it is safer, legal and ethical. Using Vivid WorkshopData ATI 12.1 can bring you many benefits as a professional mechanic or technician, such as saving time and money, improving your skills and knowledge, increasing your customer satisfaction and loyalty, boosting your reputation and credibility, and enhancing your productivity and efficiency. However, Vivid WorkshopData ATI 12.1 is not the only software program that offers technical information for electrical motor diagnostics, repair and maintenance of European cars. There are some alternatives that you can consider, such as Autodata, Alldata and Mitchell. To choose the best software program for your needs, you need to consider some factors, such as your budget, your preferences and your requirements.
-How to troubleshoot common problems with Vivid WorkshopData ATI 12.1?
-Vivid WorkshopData ATI 12.1 is a software program that usually works smoothly and efficiently. However, sometimes you may encounter some problems or errors that prevent you from using it properly. Here are some common problems and solutions that you can try:
--
-
- Problem: The software does not start or crashes frequently. -
- Solution: Check if your computer meets the minimum system requirements for Vivid WorkshopData ATI 12.1. You can find them on the official website of HaynesPro: https://www.haynespro.com/en/system-requirements/. Also, make sure that you have installed the latest updates and patches for the software. You can download them from the official website of HaynesPro: https://www.haynespro.com/en/downloads/. -
- Problem: The license key is invalid or expired. -
- Solution: Check if you have entered the license key correctly and without any spaces or typos. Also, make sure that you have not used the license key on more than one computer or device. If you have bought the license key from an authorized dealer, contact them for assistance. If you have cracked the license key from a third-party source, you may need to find a new one. -
- Problem: The technical information is incomplete or inaccurate. -
- Solution: Check if you have selected the correct vehicle model and year from the database. Also, make sure that you have updated the software to the latest version and data release. You can download them from the official website of HaynesPro: https://www.haynespro.com/en/downloads/. If you still find any errors or discrepancies in the technical information, you can report them to HaynesPro: https://www.haynespro.com/en/contact/. -
How to get help and support for Vivid WorkshopData ATI 12.1?
-If you need any help or support for Vivid WorkshopData ATI 12.1, you can contact HaynesPro through various channels, such as:
--
-
- Email: You can send an email to info@haynespro.com or support@haynespro.com and get a reply within 24 hours. -
- Phone: You can call +31 (0)35 603 62 70 from Monday to Friday between 9:00 and 17:00 CET. -
- Online: You can visit the official website of HaynesPro: https://www.haynespro.com/en/ and access the online help center, FAQ section, user manuals, video tutorials and more. -
- Social media: You can follow HaynesPro on Facebook, Twitter, LinkedIn and YouTube and get the latest news, updates and tips. -
Conclusion
-Vivid WorkshopData ATI 12.1 is a software program that provides comprehensive and up-to-date technical information for electrical motor diagnostics, repair and maintenance of European cars. To use it, you need to have a valid license key that activates the software on your computer. You can either buy a license key from an authorized dealer of HaynesPro or crack a license key from a third-party source. However, we strongly recommend the first option as it is safer, legal and ethical. Using Vivid WorkshopData ATI 12.1 can bring you many benefits as a professional mechanic or technician, such as saving time and money, improving your skills and knowledge, increasing your customer satisfaction and loyalty, boosting your reputation and credibility, and enhancing your productivity and efficiency. However, Vivid WorkshopData ATI 12.1 is not the only software program that offers technical information for electrical motor diagnostics, repair and maintenance of European cars. There are some alternatives that you can consider, such as Autodata, Alldata and Mitchell. To choose the best software program for your needs, you need to consider some factors, such as your budget, your preferences and your requirements. Moreover, if you encounter any problems or errors with Vivid WorkshopData ATI 12.1, you can try some troubleshooting tips or contact HaynesPro for help and support.
-Conclusion
-Vivid WorkshopData ATI 12.1 is a software program that provides comprehensive and up-to-date technical information for electrical motor diagnostics, repair and maintenance of European cars. To use it, you need to have a valid license key that activates the software on your computer. You can either buy a license key from an authorized dealer of HaynesPro or crack a license key from a third-party source. However, we strongly recommend the first option as it is safer, legal and ethical. Using Vivid WorkshopData ATI 12.1 can bring you many benefits as a professional mechanic or technician, such as saving time and money, improving your skills and knowledge, increasing your customer satisfaction and loyalty, boosting your reputation and credibility, and enhancing your productivity and efficiency. However, Vivid WorkshopData ATI 12.1 is not the only software program that offers technical information for electrical motor diagnostics, repair and maintenance of European cars. There are some alternatives that you can consider, such as Autodata, Alldata and Mitchell. To choose the best software program for your needs, you need to consider some factors, such as your budget, your preferences and your requirements. Moreover, if you encounter any problems or errors with Vivid WorkshopData ATI 12.1, you can try some troubleshooting tips or contact HaynesPro for help and support.
3cee63e6c2
-
-
\ No newline at end of file diff --git a/spaces/inreVtussa/clothingai/Examples/American Truck Simulator 2016 Crack With License Key Free BETTER Download.md b/spaces/inreVtussa/clothingai/Examples/American Truck Simulator 2016 Crack With License Key Free BETTER Download.md deleted file mode 100644 index e693f37944242d28d2410b3ada4c26e0fe301e83..0000000000000000000000000000000000000000 --- a/spaces/inreVtussa/clothingai/Examples/American Truck Simulator 2016 Crack With License Key Free BETTER Download.md +++ /dev/null @@ -1,17 +0,0 @@ -
-Here is what I created: - -American Truck Simulator 2016 Crack with License Key Free Download
-American Truck Simulator 2016 is a realistic and immersive simulation game that lets you drive across the USA in a variety of trucks. You can customize your vehicle, explore different routes and cities, and deliver cargo to various destinations. But what if you want to play the game without paying for it? That's where American Truck Simulator 2016 Crack comes in.
-American Truck Simulator 2016 Crack is a software tool that bypasses the game's activation process and allows you to play it for free. You don't need to buy the game or enter a license key to enjoy its features. All you need to do is download the crack file from a reliable source, install it on your PC, and run the game. It's that simple!
-American Truck Simulator 2016 Crack with License Key Free Download
Download ✓ https://tiurll.com/2uClPG
-However, before you download American Truck Simulator 2016 Crack, you should be aware of the risks involved. First of all, cracking a game is illegal and violates the terms of service of the developers and publishers. You could face legal consequences if you get caught. Second, downloading crack files from unknown sources could expose your PC to malware, viruses, or spyware. You could lose your data, compromise your security, or damage your system. Third, using a crack could affect the performance and quality of the game. You could experience bugs, glitches, crashes, or errors that ruin your gaming experience. You could also miss out on updates, patches, or online features that enhance the game.
-Therefore, we do not recommend using American Truck Simulator 2016 Crack or any other crack for that matter. If you want to play the game, you should buy it from a legitimate source and support the developers who worked hard to create it. You will get a better and safer gaming experience that way.
-Here is what I created: - -So, how can you play American Truck Simulator 2016 legally and safely? The answer is simple: buy the game from the official website or a trusted online store. You can choose from different editions and bundles that suit your budget and preferences. You can also get access to additional content, such as DLCs, mods, or community creations. You can also join the online community of truckers and share your experiences, tips, or feedback with other players.
-Buying the game will also ensure that you get the best possible gaming experience. You will be able to enjoy the game's realistic graphics, physics, and sound effects that make you feel like you are driving a real truck. You will also be able to explore the game's vast and diverse map that covers different regions and states of the USA. You will also be able to customize your truck with various parts, accessories, and paint jobs that reflect your personality and style.
-American Truck Simulator 2016 is a game that deserves your support and appreciation. It is a game that offers you hours of fun, challenge, and entertainment. It is a game that lets you live your dream of becoming a truck driver and traveling across the USA. It is a game that you should not miss out on. So, don't waste your time and money on cracks or pirated copies. Buy the game today and enjoy the ride!
- d5da3c52bf
-
-
\ No newline at end of file diff --git a/spaces/inreVtussa/clothingai/Examples/Basic Electronics By Sanjay Sharma Pdf Free Download Hit.md b/spaces/inreVtussa/clothingai/Examples/Basic Electronics By Sanjay Sharma Pdf Free Download Hit.md deleted file mode 100644 index 1b7f805fe4eb7f2d7c7cc809271780e649dc1e0b..0000000000000000000000000000000000000000 --- a/spaces/inreVtussa/clothingai/Examples/Basic Electronics By Sanjay Sharma Pdf Free Download Hit.md +++ /dev/null @@ -1,56 +0,0 @@ - -Basic Electronics by Sanjay Sharma: A Comprehensive Guide for Beginners
- -If you are looking for a book that covers the fundamentals of electronics in a clear and concise way, then you might want to check out Basic Electronics by Sanjay Sharma. This book is designed for students and amateurs who want to learn the theory and practice of electronics. It covers topics such as semiconductor devices, diode circuits, BJT circuits, FET circuits, feedback amplifiers, operational amplifiers, oscillators, digital electronics, and electronic instruments.
- -Basic Electronics by Sanjay Sharma is a well-written and well-illustrated book that uses simple language and examples to explain complex concepts. It also includes numerous solved problems and exercises to help you test your understanding and apply your knowledge. The book is suitable for self-study as well as for classroom use.
-basic electronics by sanjay sharma pdf free download hit
Download File ➡ https://tiurll.com/2uCiKL
- -One of the best features of this book is that it provides a free PDF download link for the readers. You can download the PDF version of the book from the following link: Basic Electronics by Sanjay Sharma PDF Free Download Hit. This link will take you to a website where you can access the PDF file of the book without any hassle. You can also find other useful resources and information on this website.
- -Basic Electronics by Sanjay Sharma is a must-have book for anyone who wants to learn the basics of electronics and build their own circuits. It will help you gain a solid foundation in electronics and prepare you for more advanced topics. Whether you are a student, a hobbyist, or a professional, you will find this book useful and informative.
- -So what are you waiting for? Download Basic Electronics by Sanjay Sharma PDF Free Download Hit today and start learning electronics!
- -Basic Electronics Concepts
- -Before you dive into the details of electronic circuits, you need to understand some basic concepts that are essential for electronics. These concepts include voltage, current, resistance, power, Ohm's law, Kirchhoff's laws, and Thevenin's theorem. These concepts will help you analyze and design electronic circuits and understand how they work.
- -Voltage
- -Voltage is the measure of electric potential difference between two points in a circuit. It is also called electromotive force (EMF) or potential. Voltage is the cause of electric current in a circuit. It is measured in volts (V).
- -Current
- -Current is the measure of electric charge flow through a conductor in a circuit. It is also called electric current or amperage. Current is the effect of voltage in a circuit. It is measured in amperes (A) or milliamperes (mA).
- -Resistance
- -Resistance is the measure of opposition to electric current in a circuit. It is also called electrical resistance or impedance. Resistance is the property of a material that determines how much current can flow through it for a given voltage. It is measured in ohms ($\Omega$) or kilohms (k$\Omega$).
- -Power
- -Power is the measure of electric energy consumed or delivered by a circuit element in a unit time. It is also called electrical power or wattage. Power is the product of voltage and current in a circuit. It is measured in watts (W) or milliwatts (mW).
- - -Ohm's Law
- -Ohm's law is the fundamental relationship between voltage, current, and resistance in a circuit. It states that the voltage across a resistor is directly proportional to the current through it, and inversely proportional to its resistance. The mathematical expression of Ohm's law is: - -$$V = IR$$ - -where V is the voltage in volts, I is the current in amperes, and R is the resistance in ohms.
- -Kirchhoff's Laws
- -Kirchhoff's laws are two rules that govern the conservation of charge and energy in a circuit. They are also called Kirchhoff's current law (KCL) and Kirchhoff's voltage law (KVL). - -KCL states that the algebraic sum of currents entering and leaving a node (or junction) in a circuit is zero. This means that the total charge entering a node is equal to the total charge leaving it. - -KVL states that the algebraic sum of voltages around any closed loop in a circuit is zero. This means that the total energy gained by charges moving around a loop is equal to the total energy lost by them.
- -Thevenin's Theorem
- -Thevenin's theorem is a technique that simplifies the analysis of complex circuits by replacing them with equivalent circuits consisting of a single voltage source and a single resistor. The theorem states that any linear circuit with two terminals can be replaced by an equivalent circuit with a voltage source equal to the open-circuit voltage across the terminals and a resistor equal to the equivalent resistance seen from the terminals.
d5da3c52bf
-
-
\ No newline at end of file diff --git a/spaces/ipvikas/ALL_NLP_Tasks/README.md b/spaces/ipvikas/ALL_NLP_Tasks/README.md deleted file mode 100644 index ad46a840f79244f3e4cf45523a47d51c753abd3d..0000000000000000000000000000000000000000 --- a/spaces/ipvikas/ALL_NLP_Tasks/README.md +++ /dev/null @@ -1,12 +0,0 @@ ---- -title: ALL NLP Tasks -emoji: 🌖 -colorFrom: indigo -colorTo: blue -sdk: gradio -sdk_version: 3.1.4 -app_file: app.py -pinned: false ---- - -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference diff --git a/spaces/itintelpro/MyCybersecHelper/README.md b/spaces/itintelpro/MyCybersecHelper/README.md deleted file mode 100644 index 6ebb31b17de3b3c6db6ece3a7e6910a6ffcdca99..0000000000000000000000000000000000000000 --- a/spaces/itintelpro/MyCybersecHelper/README.md +++ /dev/null @@ -1,13 +0,0 @@ ---- -title: MyCybersecHelper -emoji: 📉 -colorFrom: yellow -colorTo: purple -sdk: gradio -sdk_version: 3.24.1 -app_file: app.py -pinned: false -license: other ---- - -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference diff --git a/spaces/ixciel/img-to-music/constants.py b/spaces/ixciel/img-to-music/constants.py deleted file mode 100644 index 86863d1b778d4c66f0d8e1e0b699f1bb937c1d50..0000000000000000000000000000000000000000 --- a/spaces/ixciel/img-to-music/constants.py +++ /dev/null @@ -1,9 +0,0 @@ -import numpy as np -import os - -MUBERT_LICENSE = os.environ.get('MUBERT_LICENSE') -MUBERT_TOKEN = os.environ.get('MUBERT_TOKEN') - -MUBERT_MODE = "loop" -MUBERT_TAGS_STRING = 'tribal,action,kids,neo-classic,run 130,pumped,jazz / funk,ethnic,dubtechno,reggae,acid jazz,liquidfunk,funk,witch house,tech house,underground,artists,mystical,disco,sensorium,r&b,agender,psychedelic trance / psytrance,peaceful,run 140,piano,run 160,setting,meditation,christmas,ambient,horror,cinematic,electro house,idm,bass,minimal,underscore,drums,glitchy,beautiful,technology,tribal house,country pop,jazz & funk,documentary,space,classical,valentines,chillstep,experimental,trap,new jack swing,drama,post-rock,tense,corporate,neutral,happy,analog,funky,spiritual,sberzvuk special,chill hop,dramatic,catchy,holidays,fitness 90,optimistic,orchestra,acid techno,energizing,romantic,minimal house,breaks,hyper pop,warm up,dreamy,dark,urban,microfunk,dub,nu disco,vogue,keys,hardcore,aggressive,indie,electro funk,beauty,relaxing,trance,pop,hiphop,soft,acoustic,chillrave / ethno-house,deep techno,angry,dance,fun,dubstep,tropical,latin pop,heroic,world music,inspirational,uplifting,atmosphere,art,epic,advertising,chillout,scary,spooky,slow ballad,saxophone,summer,erotic,jazzy,energy 100,kara mar,xmas,atmospheric,indie pop,hip-hop,yoga,reggaeton,lounge,travel,running,folk,chillrave & ethno-house,detective,darkambient,chill,fantasy,minimal techno,special,night,tropical house,downtempo,lullaby,meditative,upbeat,glitch hop,fitness,neurofunk,sexual,indie rock,future pop,jazz,cyberpunk,melancholic,happy hardcore,family / kids,synths,electric guitar,comedy,psychedelic trance & psytrance,edm,psychedelic rock,calm,zen,bells,podcast,melodic house,ethnic percussion,nature,heavy,bassline,indie dance,techno,drumnbass,synth pop,vaporwave,sad,8-bit,chillgressive,deep,orchestral,futuristic,hardtechno,nostalgic,big room,sci-fi,tutorial,joyful,pads,minimal 170,drill,ethnic 108,amusing,sleepy ambient,psychill,italo disco,lofi,house,acoustic guitar,bassline house,rock,k-pop,synthwave,deep house,electronica,gabber,nightlife,sport & fitness,road trip,celebration,electro,disco house,electronic' -MUBERT_TAGS = np.array(MUBERT_TAGS_STRING.split(',')) \ No newline at end of file diff --git a/spaces/jackli888/stable-diffusion-webui/javascript/progressbar.js b/spaces/jackli888/stable-diffusion-webui/javascript/progressbar.js deleted file mode 100644 index ff6d757bae88f5f622767376e5315b9acf8271cd..0000000000000000000000000000000000000000 --- a/spaces/jackli888/stable-diffusion-webui/javascript/progressbar.js +++ /dev/null @@ -1,243 +0,0 @@ -// code related to showing and updating progressbar shown as the image is being made - - -galleries = {} -storedGallerySelections = {} -galleryObservers = {} - -function rememberGallerySelection(id_gallery){ - storedGallerySelections[id_gallery] = getGallerySelectedIndex(id_gallery) -} - -function getGallerySelectedIndex(id_gallery){ - let galleryButtons = gradioApp().querySelectorAll('#'+id_gallery+' .gallery-item') - let galleryBtnSelected = gradioApp().querySelector('#'+id_gallery+' .gallery-item.\\!ring-2') - - let currentlySelectedIndex = -1 - galleryButtons.forEach(function(v, i){ if(v==galleryBtnSelected) { currentlySelectedIndex = i } }) - - return currentlySelectedIndex -} - -// this is a workaround for https://github.com/gradio-app/gradio/issues/2984 -function check_gallery(id_gallery){ - let gallery = gradioApp().getElementById(id_gallery) - // if gallery has no change, no need to setting up observer again. - if (gallery && galleries[id_gallery] !== gallery){ - galleries[id_gallery] = gallery; - if(galleryObservers[id_gallery]){ - galleryObservers[id_gallery].disconnect(); - } - - storedGallerySelections[id_gallery] = -1 - - galleryObservers[id_gallery] = new MutationObserver(function (){ - let galleryButtons = gradioApp().querySelectorAll('#'+id_gallery+' .gallery-item') - let galleryBtnSelected = gradioApp().querySelector('#'+id_gallery+' .gallery-item.\\!ring-2') - let currentlySelectedIndex = getGallerySelectedIndex(id_gallery) - prevSelectedIndex = storedGallerySelections[id_gallery] - storedGallerySelections[id_gallery] = -1 - - if (prevSelectedIndex !== -1 && galleryButtons.length>prevSelectedIndex && !galleryBtnSelected) { - // automatically re-open previously selected index (if exists) - activeElement = gradioApp().activeElement; - let scrollX = window.scrollX; - let scrollY = window.scrollY; - - galleryButtons[prevSelectedIndex].click(); - showGalleryImage(); - - // When the gallery button is clicked, it gains focus and scrolls itself into view - // We need to scroll back to the previous position - setTimeout(function (){ - window.scrollTo(scrollX, scrollY); - }, 50); - - if(activeElement){ - // i fought this for about an hour; i don't know why the focus is lost or why this helps recover it - // if someone has a better solution please by all means - setTimeout(function (){ - activeElement.focus({ - preventScroll: true // Refocus the element that was focused before the gallery was opened without scrolling to it - }) - }, 1); - } - } - }) - galleryObservers[id_gallery].observe( gallery, { childList:true, subtree:false }) - } -} - -onUiUpdate(function(){ - check_gallery('txt2img_gallery') - check_gallery('img2img_gallery') -}) - -function request(url, data, handler, errorHandler){ - var xhr = new XMLHttpRequest(); - var url = url; - xhr.open("POST", url, true); - xhr.setRequestHeader("Content-Type", "application/json"); - xhr.onreadystatechange = function () { - if (xhr.readyState === 4) { - if (xhr.status === 200) { - try { - var js = JSON.parse(xhr.responseText); - handler(js) - } catch (error) { - console.error(error); - errorHandler() - } - } else{ - errorHandler() - } - } - }; - var js = JSON.stringify(data); - xhr.send(js); -} - -function pad2(x){ - return x<10 ? '0'+x : x -} - -function formatTime(secs){ - if(secs > 3600){ - return pad2(Math.floor(secs/60/60)) + ":" + pad2(Math.floor(secs/60)%60) + ":" + pad2(Math.floor(secs)%60) - } else if(secs > 60){ - return pad2(Math.floor(secs/60)) + ":" + pad2(Math.floor(secs)%60) - } else{ - return Math.floor(secs) + "s" - } -} - -function setTitle(progress){ - var title = 'Stable Diffusion' - - if(opts.show_progress_in_title && progress){ - title = '[' + progress.trim() + '] ' + title; - } - - if(document.title != title){ - document.title = title; - } -} - - -function randomId(){ - return "task(" + Math.random().toString(36).slice(2, 7) + Math.random().toString(36).slice(2, 7) + Math.random().toString(36).slice(2, 7)+")" -} - -// starts sending progress requests to "/internal/progress" uri, creating progressbar above progressbarContainer element and -// preview inside gallery element. Cleans up all created stuff when the task is over and calls atEnd. -// calls onProgress every time there is a progress update -function requestProgress(id_task, progressbarContainer, gallery, atEnd, onProgress){ - var dateStart = new Date() - var wasEverActive = false - var parentProgressbar = progressbarContainer.parentNode - var parentGallery = gallery ? gallery.parentNode : null - - var divProgress = document.createElement('div') - divProgress.className='progressDiv' - divProgress.style.display = opts.show_progressbar ? "" : "none" - var divInner = document.createElement('div') - divInner.className='progress' - - divProgress.appendChild(divInner) - parentProgressbar.insertBefore(divProgress, progressbarContainer) - - if(parentGallery){ - var livePreview = document.createElement('div') - livePreview.className='livePreview' - parentGallery.insertBefore(livePreview, gallery) - } - - var removeProgressBar = function(){ - setTitle("") - parentProgressbar.removeChild(divProgress) - if(parentGallery) parentGallery.removeChild(livePreview) - atEnd() - } - - var fun = function(id_task, id_live_preview){ - request("./internal/progress", {"id_task": id_task, "id_live_preview": id_live_preview}, function(res){ - if(res.completed){ - removeProgressBar() - return - } - - var rect = progressbarContainer.getBoundingClientRect() - - if(rect.width){ - divProgress.style.width = rect.width + "px"; - } - - progressText = "" - - divInner.style.width = ((res.progress || 0) * 100.0) + '%' - divInner.style.background = res.progress ? "" : "transparent" - - if(res.progress > 0){ - progressText = ((res.progress || 0) * 100.0).toFixed(0) + '%' - } - - if(res.eta){ - progressText += " ETA: " + formatTime(res.eta) - } - - - setTitle(progressText) - - if(res.textinfo && res.textinfo.indexOf("\n") == -1){ - progressText = res.textinfo + " " + progressText - } - - divInner.textContent = progressText - - var elapsedFromStart = (new Date() - dateStart) / 1000 - - if(res.active) wasEverActive = true; - - if(! res.active && wasEverActive){ - removeProgressBar() - return - } - - if(elapsedFromStart > 5 && !res.queued && !res.active){ - removeProgressBar() - return - } - - - if(res.live_preview && gallery){ - var rect = gallery.getBoundingClientRect() - if(rect.width){ - livePreview.style.width = rect.width + "px" - livePreview.style.height = rect.height + "px" - } - - var img = new Image(); - img.onload = function() { - livePreview.appendChild(img) - if(livePreview.childElementCount > 2){ - livePreview.removeChild(livePreview.firstElementChild) - } - } - img.src = res.live_preview; - } - - - if(onProgress){ - onProgress(res) - } - - setTimeout(() => { - fun(id_task, res.id_live_preview); - }, opts.live_preview_refresh_period || 500) - }, function(){ - removeProgressBar() - }) - } - - fun(id_task, 0) -} diff --git a/spaces/jackli888/stable-diffusion-webui/modules/esrgan_model.py b/spaces/jackli888/stable-diffusion-webui/modules/esrgan_model.py deleted file mode 100644 index 80131c62cfeaa7f95455df55c45d6e62591adeee..0000000000000000000000000000000000000000 --- a/spaces/jackli888/stable-diffusion-webui/modules/esrgan_model.py +++ /dev/null @@ -1,233 +0,0 @@ -import os - -import numpy as np -import torch -from PIL import Image -from basicsr.utils.download_util import load_file_from_url - -import modules.esrgan_model_arch as arch -from modules import shared, modelloader, images, devices -from modules.upscaler import Upscaler, UpscalerData -from modules.shared import opts - - - -def mod2normal(state_dict): - # this code is copied from https://github.com/victorca25/iNNfer - if 'conv_first.weight' in state_dict: - crt_net = {} - items = [] - for k, v in state_dict.items(): - items.append(k) - - crt_net['model.0.weight'] = state_dict['conv_first.weight'] - crt_net['model.0.bias'] = state_dict['conv_first.bias'] - - for k in items.copy(): - if 'RDB' in k: - ori_k = k.replace('RRDB_trunk.', 'model.1.sub.') - if '.weight' in k: - ori_k = ori_k.replace('.weight', '.0.weight') - elif '.bias' in k: - ori_k = ori_k.replace('.bias', '.0.bias') - crt_net[ori_k] = state_dict[k] - items.remove(k) - - crt_net['model.1.sub.23.weight'] = state_dict['trunk_conv.weight'] - crt_net['model.1.sub.23.bias'] = state_dict['trunk_conv.bias'] - crt_net['model.3.weight'] = state_dict['upconv1.weight'] - crt_net['model.3.bias'] = state_dict['upconv1.bias'] - crt_net['model.6.weight'] = state_dict['upconv2.weight'] - crt_net['model.6.bias'] = state_dict['upconv2.bias'] - crt_net['model.8.weight'] = state_dict['HRconv.weight'] - crt_net['model.8.bias'] = state_dict['HRconv.bias'] - crt_net['model.10.weight'] = state_dict['conv_last.weight'] - crt_net['model.10.bias'] = state_dict['conv_last.bias'] - state_dict = crt_net - return state_dict - - -def resrgan2normal(state_dict, nb=23): - # this code is copied from https://github.com/victorca25/iNNfer - if "conv_first.weight" in state_dict and "body.0.rdb1.conv1.weight" in state_dict: - re8x = 0 - crt_net = {} - items = [] - for k, v in state_dict.items(): - items.append(k) - - crt_net['model.0.weight'] = state_dict['conv_first.weight'] - crt_net['model.0.bias'] = state_dict['conv_first.bias'] - - for k in items.copy(): - if "rdb" in k: - ori_k = k.replace('body.', 'model.1.sub.') - ori_k = ori_k.replace('.rdb', '.RDB') - if '.weight' in k: - ori_k = ori_k.replace('.weight', '.0.weight') - elif '.bias' in k: - ori_k = ori_k.replace('.bias', '.0.bias') - crt_net[ori_k] = state_dict[k] - items.remove(k) - - crt_net[f'model.1.sub.{nb}.weight'] = state_dict['conv_body.weight'] - crt_net[f'model.1.sub.{nb}.bias'] = state_dict['conv_body.bias'] - crt_net['model.3.weight'] = state_dict['conv_up1.weight'] - crt_net['model.3.bias'] = state_dict['conv_up1.bias'] - crt_net['model.6.weight'] = state_dict['conv_up2.weight'] - crt_net['model.6.bias'] = state_dict['conv_up2.bias'] - - if 'conv_up3.weight' in state_dict: - # modification supporting: https://github.com/ai-forever/Real-ESRGAN/blob/main/RealESRGAN/rrdbnet_arch.py - re8x = 3 - crt_net['model.9.weight'] = state_dict['conv_up3.weight'] - crt_net['model.9.bias'] = state_dict['conv_up3.bias'] - - crt_net[f'model.{8+re8x}.weight'] = state_dict['conv_hr.weight'] - crt_net[f'model.{8+re8x}.bias'] = state_dict['conv_hr.bias'] - crt_net[f'model.{10+re8x}.weight'] = state_dict['conv_last.weight'] - crt_net[f'model.{10+re8x}.bias'] = state_dict['conv_last.bias'] - - state_dict = crt_net - return state_dict - - -def infer_params(state_dict): - # this code is copied from https://github.com/victorca25/iNNfer - scale2x = 0 - scalemin = 6 - n_uplayer = 0 - plus = False - - for block in list(state_dict): - parts = block.split(".") - n_parts = len(parts) - if n_parts == 5 and parts[2] == "sub": - nb = int(parts[3]) - elif n_parts == 3: - part_num = int(parts[1]) - if (part_num > scalemin - and parts[0] == "model" - and parts[2] == "weight"): - scale2x += 1 - if part_num > n_uplayer: - n_uplayer = part_num - out_nc = state_dict[block].shape[0] - if not plus and "conv1x1" in block: - plus = True - - nf = state_dict["model.0.weight"].shape[0] - in_nc = state_dict["model.0.weight"].shape[1] - out_nc = out_nc - scale = 2 ** scale2x - - return in_nc, out_nc, nf, nb, plus, scale - - -class UpscalerESRGAN(Upscaler): - def __init__(self, dirname): - self.name = "ESRGAN" - self.model_url = "https://github.com/cszn/KAIR/releases/download/v1.0/ESRGAN.pth" - self.model_name = "ESRGAN_4x" - self.scalers = [] - self.user_path = dirname - super().__init__() - model_paths = self.find_models(ext_filter=[".pt", ".pth"]) - scalers = [] - if len(model_paths) == 0: - scaler_data = UpscalerData(self.model_name, self.model_url, self, 4) - scalers.append(scaler_data) - for file in model_paths: - if "http" in file: - name = self.model_name - else: - name = modelloader.friendly_name(file) - - scaler_data = UpscalerData(name, file, self, 4) - self.scalers.append(scaler_data) - - def do_upscale(self, img, selected_model): - model = self.load_model(selected_model) - if model is None: - return img - model.to(devices.device_esrgan) - img = esrgan_upscale(model, img) - return img - - def load_model(self, path: str): - if "http" in path: - filename = load_file_from_url(url=self.model_url, model_dir=self.model_path, - file_name="%s.pth" % self.model_name, - progress=True) - else: - filename = path - if not os.path.exists(filename) or filename is None: - print("Unable to load %s from %s" % (self.model_path, filename)) - return None - - state_dict = torch.load(filename, map_location='cpu' if devices.device_esrgan.type == 'mps' else None) - - if "params_ema" in state_dict: - state_dict = state_dict["params_ema"] - elif "params" in state_dict: - state_dict = state_dict["params"] - num_conv = 16 if "realesr-animevideov3" in filename else 32 - model = arch.SRVGGNetCompact(num_in_ch=3, num_out_ch=3, num_feat=64, num_conv=num_conv, upscale=4, act_type='prelu') - model.load_state_dict(state_dict) - model.eval() - return model - - if "body.0.rdb1.conv1.weight" in state_dict and "conv_first.weight" in state_dict: - nb = 6 if "RealESRGAN_x4plus_anime_6B" in filename else 23 - state_dict = resrgan2normal(state_dict, nb) - elif "conv_first.weight" in state_dict: - state_dict = mod2normal(state_dict) - elif "model.0.weight" not in state_dict: - raise Exception("The file is not a recognized ESRGAN model.") - - in_nc, out_nc, nf, nb, plus, mscale = infer_params(state_dict) - - model = arch.RRDBNet(in_nc=in_nc, out_nc=out_nc, nf=nf, nb=nb, upscale=mscale, plus=plus) - model.load_state_dict(state_dict) - model.eval() - - return model - - -def upscale_without_tiling(model, img): - img = np.array(img) - img = img[:, :, ::-1] - img = np.ascontiguousarray(np.transpose(img, (2, 0, 1))) / 255 - img = torch.from_numpy(img).float() - img = img.unsqueeze(0).to(devices.device_esrgan) - with torch.no_grad(): - output = model(img) - output = output.squeeze().float().cpu().clamp_(0, 1).numpy() - output = 255. * np.moveaxis(output, 0, 2) - output = output.astype(np.uint8) - output = output[:, :, ::-1] - return Image.fromarray(output, 'RGB') - - -def esrgan_upscale(model, img): - if opts.ESRGAN_tile == 0: - return upscale_without_tiling(model, img) - - grid = images.split_grid(img, opts.ESRGAN_tile, opts.ESRGAN_tile, opts.ESRGAN_tile_overlap) - newtiles = [] - scale_factor = 1 - - for y, h, row in grid.tiles: - newrow = [] - for tiledata in row: - x, w, tile = tiledata - - output = upscale_without_tiling(model, tile) - scale_factor = output.width // tile.width - - newrow.append([x * scale_factor, w * scale_factor, output]) - newtiles.append([y * scale_factor, h * scale_factor, newrow]) - - newgrid = images.Grid(newtiles, grid.tile_w * scale_factor, grid.tile_h * scale_factor, grid.image_w * scale_factor, grid.image_h * scale_factor, grid.overlap * scale_factor) - output = images.combine_grid(newgrid) - return output diff --git a/spaces/jhwen/bingo/src/components/learn-more.tsx b/spaces/jhwen/bingo/src/components/learn-more.tsx deleted file mode 100644 index a64459ee7900a612292e117a6bda96ee9260990f..0000000000000000000000000000000000000000 --- a/spaces/jhwen/bingo/src/components/learn-more.tsx +++ /dev/null @@ -1,39 +0,0 @@ -import React from 'react' -import { SourceAttribution } from '@/lib/bots/bing/types' - -export interface LearnMoreProps { - sourceAttributions?: SourceAttribution[] -} - -export function LearnMore({ sourceAttributions }: LearnMoreProps) { - if (!sourceAttributions?.length) { - return null - } - - return ( --- ) -} diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/Crypto/Signature/DSS.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/Crypto/Signature/DSS.py deleted file mode 100644 index fa848179ef108ed53168b0bf6f2082196696a1e1..0000000000000000000000000000000000000000 --- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/Crypto/Signature/DSS.py +++ /dev/null @@ -1,403 +0,0 @@ -# -# Signature/DSS.py : DSS.py -# -# =================================================================== -# -# Copyright (c) 2014, Legrandin了解详细信息:---- {sourceAttributions.map((attribution, index) => { - const { providerDisplayName, seeMoreUrl } = attribution - const { host } = new URL(seeMoreUrl) - return ( - - {index + 1}. {host} - - ) - })} --
-
-### Please, follow these steps to contribute:
-1. Reverse a website from this list: [sites-to-reverse](https://github.com/xtekky/gpt4free/issues/40)
-2. Add it to [./testing](https://github.com/xtekky/gpt4free/tree/main/testing)
-3. Refractor it and add it to [./g4f](https://github.com/xtekky/gpt4free/tree/main/g4f)
-
-### We will be grateful to see you as a contributor!
diff --git a/spaces/kevinwang676/Bark-Voice-Cloning/app.py b/spaces/kevinwang676/Bark-Voice-Cloning/app.py
deleted file mode 100644
index dd274892625395e1d264dd7f8e7a600faa0a09b1..0000000000000000000000000000000000000000
--- a/spaces/kevinwang676/Bark-Voice-Cloning/app.py
+++ /dev/null
@@ -1,401 +0,0 @@
-from cProfile import label
-import dataclasses
-from distutils.command.check import check
-from doctest import Example
-import gradio as gr
-import os
-import sys
-import numpy as np
-import logging
-import torch
-import pytorch_seed
-import time
-
-from xml.sax import saxutils
-from bark.api import generate_with_settings
-from bark.api import save_as_prompt
-from util.settings import Settings
-#import nltk
-
-
-from bark import SAMPLE_RATE
-from cloning.clonevoice import clone_voice
-from bark.generation import SAMPLE_RATE, preload_models, _load_history_prompt, codec_decode
-from scipy.io.wavfile import write as write_wav
-from util.parseinput import split_and_recombine_text, build_ssml, is_ssml, create_clips_from_ssml
-from datetime import datetime
-from tqdm.auto import tqdm
-from util.helper import create_filename, add_id3_tag
-from swap_voice import swap_voice_from_audio
-from training.training_prepare import prepare_semantics_from_text, prepare_wavs_from_semantics
-from training.train import training_prepare_files, train
-
-settings = Settings('config.yaml')
-
-
-def generate_text_to_speech(text, selected_speaker, text_temp, waveform_temp, eos_prob, quick_generation, complete_settings, seed, batchcount, progress=gr.Progress(track_tqdm=True)):
- # Chunk the text into smaller pieces then combine the generated audio
-
- # generation settings
- if selected_speaker == 'None':
- selected_speaker = None
-
- voice_name = selected_speaker
-
- if text == None or len(text) < 1:
- if selected_speaker == None:
- raise gr.Error('No text entered!')
-
- # Extract audio data from speaker if no text and speaker selected
- voicedata = _load_history_prompt(voice_name)
- audio_arr = codec_decode(voicedata["fine_prompt"])
- result = create_filename(settings.output_folder_path, "None", "extract",".wav")
- save_wav(audio_arr, result)
- return result
-
- if batchcount < 1:
- batchcount = 1
-
-
- silenceshort = np.zeros(int((float(settings.silence_sentence) / 1000.0) * SAMPLE_RATE), dtype=np.int16) # quarter second of silence
- silencelong = np.zeros(int((float(settings.silence_speakers) / 1000.0) * SAMPLE_RATE), dtype=np.float32) # half a second of silence
- use_last_generation_as_history = "Use last generation as history" in complete_settings
- save_last_generation = "Save generation as Voice" in complete_settings
- for l in range(batchcount):
- currentseed = seed
- if seed != None and seed > 2**32 - 1:
- logger.warning(f"Seed {seed} > 2**32 - 1 (max), setting to random")
- currentseed = None
- if currentseed == None or currentseed <= 0:
- currentseed = np.random.default_rng().integers(1, 2**32 - 1)
- assert(0 < currentseed and currentseed < 2**32)
-
- progress(0, desc="Generating")
-
- full_generation = None
-
- all_parts = []
- complete_text = ""
- text = text.lstrip()
- if is_ssml(text):
- list_speak = create_clips_from_ssml(text)
- prev_speaker = None
- for i, clip in tqdm(enumerate(list_speak), total=len(list_speak)):
- selected_speaker = clip[0]
- # Add pause break between speakers
- if i > 0 and selected_speaker != prev_speaker:
- all_parts += [silencelong.copy()]
- prev_speaker = selected_speaker
- text = clip[1]
- text = saxutils.unescape(text)
- if selected_speaker == "None":
- selected_speaker = None
-
- print(f"\nGenerating Text ({i+1}/{len(list_speak)}) -> {selected_speaker} (Seed {currentseed}):`{text}`")
- complete_text += text
- with pytorch_seed.SavedRNG(currentseed):
- audio_array = generate_with_settings(text_prompt=text, voice_name=selected_speaker, semantic_temp=text_temp, coarse_temp=waveform_temp, eos_p=eos_prob)
- currentseed = torch.random.initial_seed()
- if len(list_speak) > 1:
- filename = create_filename(settings.output_folder_path, currentseed, "audioclip",".wav")
- save_wav(audio_array, filename)
- add_id3_tag(filename, text, selected_speaker, currentseed)
-
- all_parts += [audio_array]
- else:
- texts = split_and_recombine_text(text, settings.input_text_desired_length, settings.input_text_max_length)
- for i, text in tqdm(enumerate(texts), total=len(texts)):
- print(f"\nGenerating Text ({i+1}/{len(texts)}) -> {selected_speaker} (Seed {currentseed}):`{text}`")
- complete_text += text
- if quick_generation == True:
- with pytorch_seed.SavedRNG(currentseed):
- audio_array = generate_with_settings(text_prompt=text, voice_name=selected_speaker, semantic_temp=text_temp, coarse_temp=waveform_temp, eos_p=eos_prob)
- currentseed = torch.random.initial_seed()
- else:
- full_output = use_last_generation_as_history or save_last_generation
- if full_output:
- full_generation, audio_array = generate_with_settings(text_prompt=text, voice_name=voice_name, semantic_temp=text_temp, coarse_temp=waveform_temp, eos_p=eos_prob, output_full=True)
- else:
- audio_array = generate_with_settings(text_prompt=text, voice_name=voice_name, semantic_temp=text_temp, coarse_temp=waveform_temp, eos_p=eos_prob)
-
- # Noticed this in the HF Demo - convert to 16bit int -32767/32767 - most used audio format
- # audio_array = (audio_array * 32767).astype(np.int16)
-
- if len(texts) > 1:
- filename = create_filename(settings.output_folder_path, currentseed, "audioclip",".wav")
- save_wav(audio_array, filename)
- add_id3_tag(filename, text, selected_speaker, currentseed)
-
- if quick_generation == False and (save_last_generation == True or use_last_generation_as_history == True):
- # save to npz
- voice_name = create_filename(settings.output_folder_path, seed, "audioclip", ".npz")
- save_as_prompt(voice_name, full_generation)
- if use_last_generation_as_history:
- selected_speaker = voice_name
-
- all_parts += [audio_array]
- # Add short pause between sentences
- if text[-1] in "!?.\n" and i > 1:
- all_parts += [silenceshort.copy()]
-
- # save & play audio
- result = create_filename(settings.output_folder_path, currentseed, "final",".wav")
- save_wav(np.concatenate(all_parts), result)
- # write id3 tag with text truncated to 60 chars, as a precaution...
- add_id3_tag(result, complete_text, selected_speaker, currentseed)
-
- return result
-
-
-
-def save_wav(audio_array, filename):
- write_wav(filename, SAMPLE_RATE, audio_array)
-
-def save_voice(filename, semantic_prompt, coarse_prompt, fine_prompt):
- np.savez_compressed(
- filename,
- semantic_prompt=semantic_prompt,
- coarse_prompt=coarse_prompt,
- fine_prompt=fine_prompt
- )
-
-
-def on_quick_gen_changed(checkbox):
- if checkbox == False:
- return gr.CheckboxGroup.update(visible=True)
- return gr.CheckboxGroup.update(visible=False)
-
-def delete_output_files(checkbox_state):
- if checkbox_state:
- outputs_folder = os.path.join(os.getcwd(), settings.output_folder_path)
- if os.path.exists(outputs_folder):
- purgedir(outputs_folder)
- return False
-
-
-# https://stackoverflow.com/a/54494779
-def purgedir(parent):
- for root, dirs, files in os.walk(parent):
- for item in files:
- # Delete subordinate files
- filespec = os.path.join(root, item)
- os.unlink(filespec)
- for item in dirs:
- # Recursively perform this operation for subordinate directories
- purgedir(os.path.join(root, item))
-
-def convert_text_to_ssml(text, selected_speaker):
- return build_ssml(text, selected_speaker)
-
-
-def training_prepare(selected_step, num_text_generations, progress=gr.Progress(track_tqdm=True)):
- if selected_step == prepare_training_list[0]:
- prepare_semantics_from_text()
- else:
- prepare_wavs_from_semantics()
- return None
-
-
-def start_training(save_model_epoch, max_epochs, progress=gr.Progress(track_tqdm=True)):
- training_prepare_files("./training/data/", "./training/data/checkpoint/hubert_base_ls960.pt")
- train("./training/data/", save_model_epoch, max_epochs)
- return None
-
-
-
-def apply_settings(themes, input_server_name, input_server_port, input_server_public, input_desired_len, input_max_len, input_silence_break, input_silence_speaker):
- settings.selected_theme = themes
- settings.server_name = input_server_name
- settings.server_port = input_server_port
- settings.server_share = input_server_public
- settings.input_text_desired_length = input_desired_len
- settings.input_text_max_length = input_max_len
- settings.silence_sentence = input_silence_break
- settings.silence_speaker = input_silence_speaker
- settings.save()
-
-def restart():
- global restart_server
- restart_server = True
-
-
-def create_version_html():
- python_version = ".".join([str(x) for x in sys.version_info[0:3]])
- versions_html = f"""
-python: {python_version}
- •
-torch: {getattr(torch, '__long_version__',torch.__version__)}
- •
-gradio: {gr.__version__}
-"""
- return versions_html
-
-
-
-logger = logging.getLogger(__name__)
-APPTITLE = "Bark Voice Cloning UI"
-
-
-autolaunch = False
-
-if len(sys.argv) > 1:
- autolaunch = "-autolaunch" in sys.argv
-
-
-if torch.cuda.is_available() == False:
- os.environ['BARK_FORCE_CPU'] = 'True'
- logger.warning("No CUDA detected, fallback to CPU!")
-
-print(f'smallmodels={os.environ.get("SUNO_USE_SMALL_MODELS", False)}')
-print(f'enablemps={os.environ.get("SUNO_ENABLE_MPS", False)}')
-print(f'offloadcpu={os.environ.get("SUNO_OFFLOAD_CPU", False)}')
-print(f'forcecpu={os.environ.get("BARK_FORCE_CPU", False)}')
-print(f'autolaunch={autolaunch}\n\n')
-
-#print("Updating nltk\n")
-#nltk.download('punkt')
-
-print("Preloading Models\n")
-preload_models()
-
-available_themes = ["Default", "gradio/glass", "gradio/monochrome", "gradio/seafoam", "gradio/soft", "gstaff/xkcd", "freddyaboulton/dracula_revamped", "ysharma/steampunk"]
-tokenizer_language_list = ["de","en", "pl"]
-prepare_training_list = ["Step 1: Semantics from Text","Step 2: WAV from Semantics"]
-
-seed = -1
-server_name = settings.server_name
-if len(server_name) < 1:
- server_name = None
-server_port = settings.server_port
-if server_port <= 0:
- server_port = None
-global run_server
-global restart_server
-
-run_server = True
-
-while run_server:
- # Collect all existing speakers/voices in dir
- speakers_list = []
-
- for root, dirs, files in os.walk("./bark/assets/prompts"):
- for file in files:
- if file.endswith(".npz"):
- pathpart = root.replace("./bark/assets/prompts", "")
- name = os.path.join(pathpart, file[:-4])
- if name.startswith("/") or name.startswith("\\"):
- name = name[1:]
- speakers_list.append(name)
-
- speakers_list = sorted(speakers_list, key=lambda x: x.lower())
- speakers_list.insert(0, 'None')
-
- print(f'Launching {APPTITLE} Server')
-
- # Create Gradio Blocks
-
- with gr.Blocks(title=f"{APPTITLE}", mode=f"{APPTITLE}", theme=settings.selected_theme) as barkgui:
- gr.Markdown("# 🐶🎶⭐ - Bark真实拟声2.0，一键实现声音克隆 ") - gr.Markdown("###🤗 - 开启声音情感真实复刻的新纪元 🌊 ") - gr.Markdown("###🎡 - Based on [bark-gui](https://github.com/C0untFloyd/bark-gui) ") - gr.Markdown(f""" You can duplicate and use it with a GPU:-#ifndef offsetof - #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) -#endif -#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) - #ifndef __stdcall - #define __stdcall - #endif - #ifndef __cdecl - #define __cdecl - #endif - #ifndef __fastcall - #define __fastcall - #endif -#endif -#ifndef DL_IMPORT - #define DL_IMPORT(t) t -#endif -#ifndef DL_EXPORT - #define DL_EXPORT(t) t -#endif -#define __PYX_COMMA , -#ifndef HAVE_LONG_LONG - #define HAVE_LONG_LONG -#endif -#ifndef PY_LONG_LONG - #define PY_LONG_LONG LONG_LONG -#endif -#ifndef Py_HUGE_VAL - #define Py_HUGE_VAL HUGE_VAL -#endif -#if defined(GRAALVM_PYTHON) - /* For very preliminary testing purposes. Most variables are set the same as PyPy. - The existence of this section does not imply that anything works or is even tested */ - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 1 - #define CYTHON_COMPILING_IN_NOGIL 0 - #undef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 0 - #undef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #undef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 0 - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #undef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 1 - #undef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 0 - #undef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 0 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL 0 - #undef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) - #endif - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #undef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 - #endif -#elif defined(PYPY_VERSION) - #define CYTHON_COMPILING_IN_PYPY 1 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 0 - #undef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 0 - #undef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #undef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 0 - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #undef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 1 - #undef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 0 - #undef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 0 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL 0 - #undef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) - #endif - #if PY_VERSION_HEX < 0x03090000 - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #endif - #undef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 - #endif -#elif defined(CYTHON_LIMITED_API) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 1 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 0 - #undef CYTHON_CLINE_IN_TRACEBACK - #define CYTHON_CLINE_IN_TRACEBACK 0 - #undef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 0 - #undef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 1 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #undef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #endif - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #ifndef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 0 - #endif - #undef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 0 - #undef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 0 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL 0 - #undef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS 1 - #endif - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #undef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 1 - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 1 - #endif - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 - #endif -#elif defined(PY_NOGIL) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 1 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 - #endif - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #ifndef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 - #endif - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #ifndef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 0 - #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #endif - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 1 - #endif - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 -#else - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 1 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 0 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 - #endif - #ifndef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #endif - #ifndef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 1 - #endif - #if PY_MAJOR_VERSION < 3 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #ifndef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 1 - #endif - #ifndef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 1 - #endif - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 - #endif - #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #elif !defined(CYTHON_USE_UNICODE_WRITER) - #define CYTHON_USE_UNICODE_WRITER 1 - #endif - #ifndef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 0 - #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif - #ifndef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 1 - #endif - #ifndef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) - #endif - #ifndef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) - #endif - #ifndef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 1 - #endif - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS 1 - #endif - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #endif - #ifndef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #endif - #if PY_VERSION_HEX < 0x030400a1 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #elif !defined(CYTHON_USE_TP_FINALIZE) - #define CYTHON_USE_TP_FINALIZE 1 - #endif - #if PY_VERSION_HEX < 0x030600B1 - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #elif !defined(CYTHON_USE_DICT_VERSIONS) - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) - #endif - #if PY_VERSION_HEX < 0x030700A3 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #elif !defined(CYTHON_USE_EXC_INFO_STACK) - #define CYTHON_USE_EXC_INFO_STACK 1 - #endif - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 - #endif -#endif -#if !defined(CYTHON_FAST_PYCCALL) -#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) -#endif -#if !defined(CYTHON_VECTORCALL) -#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) -#endif -#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) -#if CYTHON_USE_PYLONG_INTERNALS - #if PY_MAJOR_VERSION < 3 - #include "longintrepr.h" - #endif - #undef SHIFT - #undef BASE - #undef MASK - #ifdef SIZEOF_VOID_P - enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; - #endif -#endif -#ifndef __has_attribute - #define __has_attribute(x) 0 -#endif -#ifndef __has_cpp_attribute - #define __has_cpp_attribute(x) 0 -#endif -#ifndef CYTHON_RESTRICT - #if defined(__GNUC__) - #define CYTHON_RESTRICT __restrict__ - #elif defined(_MSC_VER) && _MSC_VER >= 1400 - #define CYTHON_RESTRICT __restrict - #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - #define CYTHON_RESTRICT restrict - #else - #define CYTHON_RESTRICT - #endif -#endif -#ifndef CYTHON_UNUSED - #if defined(__cplusplus) - /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 - * but leads to warnings with -pedantic, since it is a C++17 feature */ - #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) - #if __has_cpp_attribute(maybe_unused) - #define CYTHON_UNUSED [[maybe_unused]] - #endif - #endif - #endif -#endif -#ifndef CYTHON_UNUSED -# if defined(__GNUC__) -# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) -# define CYTHON_UNUSED __attribute__ ((__unused__)) -# else -# define CYTHON_UNUSED -# endif -# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) -# define CYTHON_UNUSED __attribute__ ((__unused__)) -# else -# define CYTHON_UNUSED -# endif -#endif -#ifndef CYTHON_UNUSED_VAR -# if defined(__cplusplus) - template void CYTHON_UNUSED_VAR( const T& ) { } -# else -# define CYTHON_UNUSED_VAR(x) (void)(x) -# endif -#endif -#ifndef CYTHON_MAYBE_UNUSED_VAR - #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) -#endif -#ifndef CYTHON_NCP_UNUSED -# if CYTHON_COMPILING_IN_CPYTHON -# define CYTHON_NCP_UNUSED -# else -# define CYTHON_NCP_UNUSED CYTHON_UNUSED -# endif -#endif -#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) -#ifdef _MSC_VER - #ifndef _MSC_STDINT_H_ - #if _MSC_VER < 1300 - typedef unsigned char uint8_t; - typedef unsigned short uint16_t; - typedef unsigned int uint32_t; - #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int16 uint16_t; - typedef unsigned __int32 uint32_t; - #endif - #endif - #if _MSC_VER < 1300 - #ifdef _WIN64 - typedef unsigned long long __pyx_uintptr_t; - #else - typedef unsigned int __pyx_uintptr_t; - #endif - #else - #ifdef _WIN64 - typedef unsigned __int64 __pyx_uintptr_t; - #else - typedef unsigned __int32 __pyx_uintptr_t; - #endif - #endif -#else - #include - typedef uintptr_t __pyx_uintptr_t; -#endif -#ifndef CYTHON_FALLTHROUGH - #if defined(__cplusplus) - /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 - * but leads to warnings with -pedantic, since it is a C++17 feature */ - #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) - #if __has_cpp_attribute(fallthrough) - #define CYTHON_FALLTHROUGH [[fallthrough]] - #endif - #endif - #ifndef CYTHON_FALLTHROUGH - #if __has_cpp_attribute(clang::fallthrough) - #define CYTHON_FALLTHROUGH [[clang::fallthrough]] - #elif __has_cpp_attribute(gnu::fallthrough) - #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] - #endif - #endif - #endif - #ifndef CYTHON_FALLTHROUGH - #if __has_attribute(fallthrough) - #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) - #else - #define CYTHON_FALLTHROUGH - #endif - #endif - #if defined(__clang__) && defined(__apple_build_version__) - #if __apple_build_version__ < 7000000 - #undef CYTHON_FALLTHROUGH - #define CYTHON_FALLTHROUGH - #endif - #endif -#endif -#ifdef __cplusplus - template - struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; - #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL ::value) -#else - #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) -#endif -#if CYTHON_COMPILING_IN_PYPY == 1 - #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) -#else - #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) -#endif -#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) - -#ifndef CYTHON_INLINE - #if defined(__clang__) - #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) - #elif defined(__GNUC__) - #define CYTHON_INLINE __inline__ - #elif defined(_MSC_VER) - #define CYTHON_INLINE __inline - #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - #define CYTHON_INLINE inline - #else - #define CYTHON_INLINE - #endif -#endif - -#define __PYX_BUILD_PY_SSIZE_T "n" -#define CYTHON_FORMAT_SSIZE_T "z" -#if PY_MAJOR_VERSION < 3 - #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_DefaultClassType PyClass_Type - #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) -#else - #define __Pyx_BUILTIN_MODULE_NAME "builtins" - #define __Pyx_DefaultClassType PyType_Type -#if PY_VERSION_HEX >= 0x030B00A1 - static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, - PyObject *code, PyObject *c, PyObject* n, PyObject *v, - PyObject *fv, PyObject *cell, PyObject* fn, - PyObject *name, int fline, PyObject *lnos) { - PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; - PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *empty=NULL; - const char *fn_cstr=NULL; - const char *name_cstr=NULL; - PyCodeObject *co=NULL, *result=NULL; - PyObject *type, *value, *traceback; - PyErr_Fetch(&type, &value, &traceback); - if (!(kwds=PyDict_New())) goto end; - if (!(argcount=PyLong_FromLong(a))) goto end; - if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; - if (!(posonlyargcount=PyLong_FromLong(p))) goto end; - if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; - if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; - if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; - if (!(nlocals=PyLong_FromLong(l))) goto end; - if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; - if (!(stacksize=PyLong_FromLong(s))) goto end; - if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; - if (!(flags=PyLong_FromLong(f))) goto end; - if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; - if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; - if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; - if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; - if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto end; - if (!(empty = PyTuple_New(0))) goto end; - result = (PyCodeObject*) PyObject_Call(replace, empty, kwds); - end: - Py_XDECREF((PyObject*) co); - Py_XDECREF(kwds); - Py_XDECREF(argcount); - Py_XDECREF(posonlyargcount); - Py_XDECREF(kwonlyargcount); - Py_XDECREF(nlocals); - Py_XDECREF(stacksize); - Py_XDECREF(replace); - Py_XDECREF(empty); - if (type) { - PyErr_Restore(type, value, traceback); - } - return result; - } -#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) -#else - #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) -#endif -#endif -#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) - #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) -#else - #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) -#endif -#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) - #define __Pyx_Py_Is(x, y) Py_Is(x, y) -#else - #define __Pyx_Py_Is(x, y) ((x) == (y)) -#endif -#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) - #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) -#else - #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) -#endif -#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) - #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) -#else - #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) -#endif -#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) - #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) -#else - #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) -#endif -#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) -#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) -#else - #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) -#endif -#ifndef CO_COROUTINE - #define CO_COROUTINE 0x80 -#endif -#ifndef CO_ASYNC_GENERATOR - #define CO_ASYNC_GENERATOR 0x200 -#endif -#ifndef Py_TPFLAGS_CHECKTYPES - #define Py_TPFLAGS_CHECKTYPES 0 -#endif -#ifndef Py_TPFLAGS_HAVE_INDEX - #define Py_TPFLAGS_HAVE_INDEX 0 -#endif -#ifndef Py_TPFLAGS_HAVE_NEWBUFFER - #define Py_TPFLAGS_HAVE_NEWBUFFER 0 -#endif -#ifndef Py_TPFLAGS_HAVE_FINALIZE - #define Py_TPFLAGS_HAVE_FINALIZE 0 -#endif -#ifndef Py_TPFLAGS_SEQUENCE - #define Py_TPFLAGS_SEQUENCE 0 -#endif -#ifndef Py_TPFLAGS_MAPPING - #define Py_TPFLAGS_MAPPING 0 -#endif -#ifndef METH_STACKLESS - #define METH_STACKLESS 0 -#endif -#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) - #ifndef METH_FASTCALL - #define METH_FASTCALL 0x80 - #endif - typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); - typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, - Py_ssize_t nargs, PyObject *kwnames); -#else - #define __Pyx_PyCFunctionFast _PyCFunctionFast - #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords -#endif -#if CYTHON_METH_FASTCALL - #define __Pyx_METH_FASTCALL METH_FASTCALL - #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast - #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords -#else - #define __Pyx_METH_FASTCALL METH_VARARGS - #define __Pyx_PyCFunction_FastCall PyCFunction - #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords -#endif -#if CYTHON_VECTORCALL - #define __pyx_vectorcallfunc vectorcallfunc - #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET - #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) -#elif CYTHON_BACKPORT_VECTORCALL - typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, - size_t nargsf, PyObject *kwnames); - #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) - #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) -#else - #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 - #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) -#endif -#if PY_VERSION_HEX < 0x030900B1 - #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) - typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); -#else - #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) - #define __Pyx_PyCMethod PyCMethod -#endif -#ifndef METH_METHOD - #define METH_METHOD 0x200 -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) - #define PyObject_Malloc(s) PyMem_Malloc(s) - #define PyObject_Free(p) PyMem_Free(p) - #define PyObject_Realloc(p) PyMem_Realloc(p) -#endif -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) -#else - #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) -#endif -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_PyThreadState_Current PyThreadState_Get() -#elif !CYTHON_FAST_THREAD_STATE - #define __Pyx_PyThreadState_Current PyThreadState_GET() -#elif PY_VERSION_HEX >= 0x03060000 - #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() -#elif PY_VERSION_HEX >= 0x03000000 - #define __Pyx_PyThreadState_Current PyThreadState_GET() -#else - #define __Pyx_PyThreadState_Current _PyThreadState_Current -#endif -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) -{ - void *result; - result = PyModule_GetState(op); - if (!result) - Py_FatalError("Couldn't find the module state"); - return result; -} -#endif -#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) -#else - #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) -#endif -#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) -#include "pythread.h" -#define Py_tss_NEEDS_INIT 0 -typedef int Py_tss_t; -static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { - *key = PyThread_create_key(); - return 0; -} -static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { - Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); - *key = Py_tss_NEEDS_INIT; - return key; -} -static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { - PyObject_Free(key); -} -static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { - return *key != Py_tss_NEEDS_INIT; -} -static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { - PyThread_delete_key(*key); - *key = Py_tss_NEEDS_INIT; -} -static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { - return PyThread_set_key_value(*key, value); -} -static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { - return PyThread_get_key_value(*key); -} -#endif -#if PY_MAJOR_VERSION < 3 - #if CYTHON_COMPILING_IN_PYPY - #if PYPY_VERSION_NUM < 0x07030600 - #if defined(__cplusplus) && __cplusplus >= 201402L - [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] - #elif defined(__GNUC__) || defined(__clang__) - __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) - #elif defined(_MSC_VER) - __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) - #endif - static CYTHON_INLINE int PyGILState_Check(void) { - return 0; - } - #else // PYPY_VERSION_NUM < 0x07030600 - #endif // PYPY_VERSION_NUM < 0x07030600 - #else - static CYTHON_INLINE int PyGILState_Check(void) { - PyThreadState * tstate = _PyThreadState_Current; - return tstate && (tstate == PyGILState_GetThisThreadState()); - } - #endif -#endif -#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) -#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) -#else -#define __Pyx_PyDict_NewPresized(n) PyDict_New() -#endif -#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION - #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) -#else - #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && CYTHON_USE_UNICODE_INTERNALS -#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) -static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { - PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); - if (res == NULL) PyErr_Clear(); - return res; -} -#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) -#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError -#define __Pyx_PyDict_GetItemStr PyDict_GetItem -#else -static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { -#if CYTHON_COMPILING_IN_PYPY - return PyDict_GetItem(dict, name); -#else - PyDictEntry *ep; - PyDictObject *mp = (PyDictObject*) dict; - long hash = ((PyStringObject *) name)->ob_shash; - assert(hash != -1); - ep = (mp->ma_lookup)(mp, name, hash); - if (ep == NULL) { - return NULL; - } - return ep->me_value; -#endif -} -#define __Pyx_PyDict_GetItemStr PyDict_GetItem -#endif -#if CYTHON_USE_TYPE_SLOTS - #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) - #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) - #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) -#else - #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) - #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) - #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next -#endif -#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 -#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ - PyTypeObject *type = Py_TYPE(obj);\ - assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ - PyObject_GC_Del(obj);\ - Py_DECREF(type);\ -} -#else -#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) -#endif -#if CYTHON_COMPILING_IN_LIMITED_API - #define CYTHON_PEP393_ENABLED 1 - #define __Pyx_PyUnicode_READY(op) (0) - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) - #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) - #define __Pyx_PyUnicode_DATA(u) ((void*)u) - #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) -#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) - #define CYTHON_PEP393_ENABLED 1 - #if PY_VERSION_HEX >= 0x030C0000 - #define __Pyx_PyUnicode_READY(op) (0) - #else - #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ - 0 : _PyUnicode_Ready((PyObject *)(op))) - #endif - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) - #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) - #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) - #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, (Py_UCS4) ch) - #if PY_VERSION_HEX >= 0x030C0000 - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) - #else - #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) - #else - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) - #endif - #endif -#else - #define CYTHON_PEP393_ENABLED 0 - #define PyUnicode_1BYTE_KIND 1 - #define PyUnicode_2BYTE_KIND 2 - #define PyUnicode_4BYTE_KIND 4 - #define __Pyx_PyUnicode_READY(op) (0) - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) - #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE)) - #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) - #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) -#endif -#if CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) - #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) -#else - #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) - #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ - PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) -#endif -#if CYTHON_COMPILING_IN_PYPY - #if !defined(PyUnicode_DecodeUnicodeEscape) - #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) - #endif - #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) - #undef PyUnicode_Contains - #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) - #endif - #if !defined(PyByteArray_Check) - #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) - #endif - #if !defined(PyObject_Format) - #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) - #endif -#endif -#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) -#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) -#else - #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) -#endif -#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) - #define PyObject_ASCII(o) PyObject_Repr(o) -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyBaseString_Type PyUnicode_Type - #define PyStringObject PyUnicodeObject - #define PyString_Type PyUnicode_Type - #define PyString_Check PyUnicode_Check - #define PyString_CheckExact PyUnicode_CheckExact -#ifndef PyObject_Unicode - #define PyObject_Unicode PyObject_Str -#endif -#endif -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) - #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) -#else - #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) - #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) -#endif -#if CYTHON_COMPILING_IN_CPYTHON - #define __Pyx_PySequence_ListKeepNew(obj)\ - (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) -#else - #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) -#endif -#ifndef PySet_CheckExact - #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) -#endif -#if PY_VERSION_HEX >= 0x030900A4 - #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) - #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) -#else - #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) - #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) -#endif -#if CYTHON_ASSUME_SAFE_MACROS - #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) -#else - #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyIntObject PyLongObject - #define PyInt_Type PyLong_Type - #define PyInt_Check(op) PyLong_Check(op) - #define PyInt_CheckExact(op) PyLong_CheckExact(op) - #define __Pyx_Py3Int_Check(op) PyLong_Check(op) - #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) - #define PyInt_FromString PyLong_FromString - #define PyInt_FromUnicode PyLong_FromUnicode - #define PyInt_FromLong PyLong_FromLong - #define PyInt_FromSize_t PyLong_FromSize_t - #define PyInt_FromSsize_t PyLong_FromSsize_t - #define PyInt_AsLong PyLong_AsLong - #define PyInt_AS_LONG PyLong_AS_LONG - #define PyInt_AsSsize_t PyLong_AsSsize_t - #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask - #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask - #define PyNumber_Int PyNumber_Long -#else - #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) - #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyBoolObject PyLongObject -#endif -#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY - #ifndef PyUnicode_InternFromString - #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) - #endif -#endif -#if PY_VERSION_HEX < 0x030200A4 - typedef long Py_hash_t; - #define __Pyx_PyInt_FromHash_t PyInt_FromLong - #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t -#else - #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t - #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t -#endif -#if CYTHON_USE_ASYNC_SLOTS - #if PY_VERSION_HEX >= 0x030500B1 - #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods - #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) - #else - #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) - #endif -#else - #define __Pyx_PyType_AsAsync(obj) NULL -#endif -#ifndef __Pyx_PyAsyncMethodsStruct - typedef struct { - unaryfunc am_await; - unaryfunc am_aiter; - unaryfunc am_anext; - } __Pyx_PyAsyncMethodsStruct; -#endif - -#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) - #if !defined(_USE_MATH_DEFINES) - #define _USE_MATH_DEFINES - #endif -#endif -#include -#ifdef NAN -#define __PYX_NAN() ((float) NAN) -#else -static CYTHON_INLINE float __PYX_NAN() { - float value; - memset(&value, 0xFF, sizeof(value)); - return value; -} -#endif -#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) -#define __Pyx_truncl trunc -#else -#define __Pyx_truncl truncl -#endif - -#define __PYX_MARK_ERR_POS(f_index, lineno) \ - { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } -#define __PYX_ERR(f_index, lineno, Ln_error) \ - { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } - -#ifdef CYTHON_EXTERN_C - #undef __PYX_EXTERN_C - #define __PYX_EXTERN_C CYTHON_EXTERN_C -#elif defined(__PYX_EXTERN_C) - #ifdef _MSC_VER - #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") - #else - #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. - #endif -#else - #ifdef __cplusplus - #define __PYX_EXTERN_C extern "C" - #else - #define __PYX_EXTERN_C extern - #endif -#endif - -#define __PYX_HAVE__monotonic_align__core -#define __PYX_HAVE_API__monotonic_align__core -/* Early includes */ -#include "pythread.h" -#include -#include -#ifdef _OPENMP -#include -#endif /* _OPENMP */ - -#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) -#define CYTHON_WITHOUT_ASSERTIONS -#endif - -typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; - const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; - -#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 -#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 -#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) -#define __PYX_DEFAULT_STRING_ENCODING "" -#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString -#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize -#define __Pyx_uchar_cast(c) ((unsigned char)c) -#define __Pyx_long_cast(x) ((long)x) -#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ - (sizeof(type) < sizeof(Py_ssize_t)) ||\ - (sizeof(type) > sizeof(Py_ssize_t) &&\ - likely(v < (type)PY_SSIZE_T_MAX ||\ - v == (type)PY_SSIZE_T_MAX) &&\ - (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ - v == (type)PY_SSIZE_T_MIN))) ||\ - (sizeof(type) == sizeof(Py_ssize_t) &&\ - (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ - v == (type)PY_SSIZE_T_MAX))) ) -static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { - return (size_t) i < (size_t) limit; -} -#if defined (__cplusplus) && __cplusplus >= 201103L - #include - #define __Pyx_sst_abs(value) std::abs(value) -#elif SIZEOF_INT >= SIZEOF_SIZE_T - #define __Pyx_sst_abs(value) abs(value) -#elif SIZEOF_LONG >= SIZEOF_SIZE_T - #define __Pyx_sst_abs(value) labs(value) -#elif defined (_MSC_VER) - #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) -#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - #define __Pyx_sst_abs(value) llabs(value) -#elif defined (__GNUC__) - #define __Pyx_sst_abs(value) __builtin_llabs(value) -#else - #define __Pyx_sst_abs(value) ((value<0) ? -value : value) -#endif -static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); -static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); -#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) -#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) -#define __Pyx_PyBytes_FromString PyBytes_FromString -#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); -#if PY_MAJOR_VERSION < 3 - #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString - #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize -#else - #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString - #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize -#endif -#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) -#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) -#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) -#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) -#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const wchar_t *u) -{ - const wchar_t *u_end = u; - while (*u_end++) ; - return (size_t)(u_end - u - 1); -} -#else -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) -{ - const Py_UNICODE *u_end = u; - while (*u_end++) ; - return (size_t)(u_end - u - 1); -} -#endif -#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) -#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) -#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode -#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode -#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) -#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) -static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); -static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); -static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); -#define __Pyx_PySequence_Tuple(obj)\ - (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) -static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); -static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); -static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); -#if CYTHON_ASSUME_SAFE_MACROS -#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) -#else -#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) -#endif -#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) -#if PY_MAJOR_VERSION >= 3 -#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) -#else -#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) -#endif -#if CYTHON_USE_PYLONG_INTERNALS - #if PY_VERSION_HEX >= 0x030C00A7 - #ifndef _PyLong_SIGN_MASK - #define _PyLong_SIGN_MASK 3 - #endif - #ifndef _PyLong_NON_SIZE_BITS - #define _PyLong_NON_SIZE_BITS 3 - #endif - #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) - #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) - #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) - #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) - #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) - #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) - #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) - #define __Pyx_PyLong_SignedDigitCount(x)\ - ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) - #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) - #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) - #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) - #else - #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) - #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) - #endif - typedef Py_ssize_t __Pyx_compact_pylong; - typedef size_t __Pyx_compact_upylong; - #else // Py < 3.12 - #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) - #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) - #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) - #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) - #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) - #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) - #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) - #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) - #define __Pyx_PyLong_CompactValue(x)\ - ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) - typedef sdigit __Pyx_compact_pylong; - typedef digit __Pyx_compact_upylong; - #endif - #if PY_VERSION_HEX >= 0x030C00A5 - #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) - #else - #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) - #endif -#endif -#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII -static int __Pyx_sys_getdefaultencoding_not_ascii; -static int __Pyx_init_sys_getdefaultencoding_params(void) { - PyObject* sys; - PyObject* default_encoding = NULL; - PyObject* ascii_chars_u = NULL; - PyObject* ascii_chars_b = NULL; - const char* default_encoding_c; - sys = PyImport_ImportModule("sys"); - if (!sys) goto bad; - default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); - Py_DECREF(sys); - if (!default_encoding) goto bad; - default_encoding_c = PyBytes_AsString(default_encoding); - if (!default_encoding_c) goto bad; - if (strcmp(default_encoding_c, "ascii") == 0) { - __Pyx_sys_getdefaultencoding_not_ascii = 0; - } else { - char ascii_chars[128]; - int c; - for (c = 0; c < 128; c++) { - ascii_chars[c] = (char) c; - } - __Pyx_sys_getdefaultencoding_not_ascii = 1; - ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); - if (!ascii_chars_u) goto bad; - ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); - if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { - PyErr_Format( - PyExc_ValueError, - "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", - default_encoding_c); - goto bad; - } - Py_DECREF(ascii_chars_u); - Py_DECREF(ascii_chars_b); - } - Py_DECREF(default_encoding); - return 0; -bad: - Py_XDECREF(default_encoding); - Py_XDECREF(ascii_chars_u); - Py_XDECREF(ascii_chars_b); - return -1; -} -#endif -#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 -#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) -#else -#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) -#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT -static char* __PYX_DEFAULT_STRING_ENCODING; -static int __Pyx_init_sys_getdefaultencoding_params(void) { - PyObject* sys; - PyObject* default_encoding = NULL; - char* default_encoding_c; - sys = PyImport_ImportModule("sys"); - if (!sys) goto bad; - default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); - Py_DECREF(sys); - if (!default_encoding) goto bad; - default_encoding_c = PyBytes_AsString(default_encoding); - if (!default_encoding_c) goto bad; - __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); - if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; - strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); - Py_DECREF(default_encoding); - return 0; -bad: - Py_XDECREF(default_encoding); - return -1; -} -#endif -#endif - - -/* Test for GCC > 2.95 */ -#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) - #define likely(x) __builtin_expect(!!(x), 1) - #define unlikely(x) __builtin_expect(!!(x), 0) -#else /* !__GNUC__ or GCC < 2.95 */ - #define likely(x) (x) - #define unlikely(x) (x) -#endif /* __GNUC__ */ -static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } - -#if !CYTHON_USE_MODULE_STATE -static PyObject *__pyx_m = NULL; -#endif -static int __pyx_lineno; -static int __pyx_clineno = 0; -static const char * __pyx_cfilenm = __FILE__; -static const char *__pyx_filename; - -/* #### Code section: filename_table ### */ - -static const char *__pyx_f[] = { - "core.pyx", - " ", -}; -/* #### Code section: utility_code_proto_before_types ### */ -/* ForceInitThreads.proto */ -#ifndef __PYX_FORCE_INIT_THREADS - #define __PYX_FORCE_INIT_THREADS 0 -#endif - -/* NoFastGil.proto */ -#define __Pyx_PyGILState_Ensure PyGILState_Ensure -#define __Pyx_PyGILState_Release PyGILState_Release -#define __Pyx_FastGIL_Remember() -#define __Pyx_FastGIL_Forget() -#define __Pyx_FastGilFuncInit() - -/* BufferFormatStructs.proto */ -struct __Pyx_StructField_; -#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) -typedef struct { - const char* name; - struct __Pyx_StructField_* fields; - size_t size; - size_t arraysize[8]; - int ndim; - char typegroup; - char is_unsigned; - int flags; -} __Pyx_TypeInfo; -typedef struct __Pyx_StructField_ { - __Pyx_TypeInfo* type; - const char* name; - size_t offset; -} __Pyx_StructField; -typedef struct { - __Pyx_StructField* field; - size_t parent_offset; -} __Pyx_BufFmt_StackElem; -typedef struct { - __Pyx_StructField root; - __Pyx_BufFmt_StackElem* head; - size_t fmt_offset; - size_t new_count, enc_count; - size_t struct_alignment; - int is_complex; - char enc_type; - char new_packmode; - char enc_packmode; - char is_valid_array; -} __Pyx_BufFmt_Context; - -/* Atomics.proto */ -#include -#ifndef CYTHON_ATOMICS - #define CYTHON_ATOMICS 1 -#endif -#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS -#define __pyx_atomic_int_type int -#define __pyx_nonatomic_int_type int -#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ - (__STDC_VERSION__ >= 201112L) &&\ - !defined(__STDC_NO_ATOMICS__)) - #include -#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ - (__cplusplus >= 201103L) ||\ - (defined(_MSC_VER) && _MSC_VER >= 1700))) - #include -#endif -#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ - (__STDC_VERSION__ >= 201112L) &&\ - !defined(__STDC_NO_ATOMICS__) &&\ - ATOMIC_INT_LOCK_FREE == 2) - #undef __pyx_atomic_int_type - #define __pyx_atomic_int_type atomic_int - #define __pyx_atomic_incr_aligned(value) atomic_fetch_add_explicit(value, 1, memory_order_relaxed) - #define __pyx_atomic_decr_aligned(value) atomic_fetch_sub_explicit(value, 1, memory_order_acq_rel) - #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) - #pragma message ("Using standard C atomics") - #elif defined(__PYX_DEBUG_ATOMICS) - #warning "Using standard C atomics" - #endif -#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ - (__cplusplus >= 201103L) ||\ -\ - (defined(_MSC_VER) && _MSC_VER >= 1700)) &&\ - ATOMIC_INT_LOCK_FREE == 2) - #undef __pyx_atomic_int_type - #define __pyx_atomic_int_type std::atomic_int - #define __pyx_atomic_incr_aligned(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_relaxed) - #define __pyx_atomic_decr_aligned(value) std::atomic_fetch_sub_explicit(value, 1, std::memory_order_acq_rel) - #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) - #pragma message ("Using standard C++ atomics") - #elif defined(__PYX_DEBUG_ATOMICS) - #warning "Using standard C++ atomics" - #endif -#elif CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\ - (__GNUC_MINOR__ > 1 ||\ - (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2)))) - #define __pyx_atomic_incr_aligned(value) __sync_fetch_and_add(value, 1) - #define __pyx_atomic_decr_aligned(value) __sync_fetch_and_sub(value, 1) - #ifdef __PYX_DEBUG_ATOMICS - #warning "Using GNU atomics" - #endif -#elif CYTHON_ATOMICS && defined(_MSC_VER) - #include - #undef __pyx_atomic_int_type - #define __pyx_atomic_int_type long - #define __pyx_nonatomic_int_type long - #pragma intrinsic (_InterlockedExchangeAdd) - #define __pyx_atomic_incr_aligned(value) _InterlockedExchangeAdd(value, 1) - #define __pyx_atomic_decr_aligned(value) _InterlockedExchangeAdd(value, -1) - #ifdef __PYX_DEBUG_ATOMICS - #pragma message ("Using MSVC atomics") - #endif -#else - #undef CYTHON_ATOMICS - #define CYTHON_ATOMICS 0 - #ifdef __PYX_DEBUG_ATOMICS - #warning "Not using atomics" - #endif -#endif -#if CYTHON_ATOMICS - #define __pyx_add_acquisition_count(memview)\ - __pyx_atomic_incr_aligned(__pyx_get_slice_count_pointer(memview)) - #define __pyx_sub_acquisition_count(memview)\ - __pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview)) -#else - #define __pyx_add_acquisition_count(memview)\ - __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) - #define __pyx_sub_acquisition_count(memview)\ - __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) -#endif - -/* MemviewSliceStruct.proto */ -struct __pyx_memoryview_obj; -typedef struct { - struct __pyx_memoryview_obj *memview; - char *data; - Py_ssize_t shape[8]; - Py_ssize_t strides[8]; - Py_ssize_t suboffsets[8]; -} __Pyx_memviewslice; -#define __Pyx_MemoryView_Len(m) (m.shape[0]) - -/* #### Code section: numeric_typedefs ### */ -/* #### Code section: complex_type_declarations ### */ -/* #### Code section: type_declarations ### */ - -/*--- Type declarations ---*/ -struct __pyx_array_obj; -struct __pyx_MemviewEnum_obj; -struct __pyx_memoryview_obj; -struct __pyx_memoryviewslice_obj; -struct __pyx_opt_args_15monotonic_align_4core_maximum_path_each; - -/* "monotonic_align/core.pyx":7 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * cdef void maximum_path_each(int[:,::1] path, float[:,::1] value, int t_y, int t_x, float max_neg_val=-1e9) nogil: # <<<<<<<<<<<<<< - * cdef int x - * cdef int y - */ -struct __pyx_opt_args_15monotonic_align_4core_maximum_path_each { - int __pyx_n; - float max_neg_val; -}; - -/* "View.MemoryView":114 - * @cython.collection_type("sequence") - * @cname("__pyx_array") - * cdef class array: # <<<<<<<<<<<<<< - * - * cdef: - */ -struct __pyx_array_obj { - PyObject_HEAD - struct __pyx_vtabstruct_array *__pyx_vtab; - char *data; - Py_ssize_t len; - char *format; - int ndim; - Py_ssize_t *_shape; - Py_ssize_t *_strides; - Py_ssize_t itemsize; - PyObject *mode; - PyObject *_format; - void (*callback_free_data)(void *); - int free_data; - int dtype_is_object; -}; - - -/* "View.MemoryView":302 - * - * @cname('__pyx_MemviewEnum') - * cdef class Enum(object): # <<<<<<<<<<<<<< - * cdef object name - * def __init__(self, name): - */ -struct __pyx_MemviewEnum_obj { - PyObject_HEAD - PyObject *name; -}; - - -/* "View.MemoryView":337 - * - * @cname('__pyx_memoryview') - * cdef class memoryview: # <<<<<<<<<<<<<< - * - * cdef object obj - */ -struct __pyx_memoryview_obj { - PyObject_HEAD - struct __pyx_vtabstruct_memoryview *__pyx_vtab; - PyObject *obj; - PyObject *_size; - PyObject *_array_interface; - PyThread_type_lock lock; - __pyx_atomic_int_type acquisition_count; - Py_buffer view; - int flags; - int dtype_is_object; - __Pyx_TypeInfo *typeinfo; -}; - - -/* "View.MemoryView":952 - * @cython.collection_type("sequence") - * @cname('__pyx_memoryviewslice') - * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< - * "Internal class for passing memoryview slices to Python" - * - */ -struct __pyx_memoryviewslice_obj { - struct __pyx_memoryview_obj __pyx_base; - __Pyx_memviewslice from_slice; - PyObject *from_object; - PyObject *(*to_object_func)(char *); - int (*to_dtype_func)(char *, PyObject *); -}; - - - -/* "View.MemoryView":114 - * @cython.collection_type("sequence") - * @cname("__pyx_array") - * cdef class array: # <<<<<<<<<<<<<< - * - * cdef: - */ - -struct __pyx_vtabstruct_array { - PyObject *(*get_memview)(struct __pyx_array_obj *); -}; -static struct __pyx_vtabstruct_array *__pyx_vtabptr_array; - - -/* "View.MemoryView":337 - * - * @cname('__pyx_memoryview') - * cdef class memoryview: # <<<<<<<<<<<<<< - * - * cdef object obj - */ - -struct __pyx_vtabstruct_memoryview { - char *(*get_item_pointer)(struct __pyx_memoryview_obj *, PyObject *); - PyObject *(*is_slice)(struct __pyx_memoryview_obj *, PyObject *); - PyObject *(*setitem_slice_assignment)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); - PyObject *(*setitem_slice_assign_scalar)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *); - PyObject *(*setitem_indexed)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); - PyObject *(*convert_item_to_object)(struct __pyx_memoryview_obj *, char *); - PyObject *(*assign_item_from_object)(struct __pyx_memoryview_obj *, char *, PyObject *); - PyObject *(*_get_base)(struct __pyx_memoryview_obj *); -}; -static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview; - - -/* "View.MemoryView":952 - * @cython.collection_type("sequence") - * @cname('__pyx_memoryviewslice') - * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< - * "Internal class for passing memoryview slices to Python" - * - */ - -struct __pyx_vtabstruct__memoryviewslice { - struct __pyx_vtabstruct_memoryview __pyx_base; -}; -static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice; -/* #### Code section: utility_code_proto ### */ - -/* --- Runtime support code (head) --- */ -/* Refnanny.proto */ -#ifndef CYTHON_REFNANNY - #define CYTHON_REFNANNY 0 -#endif -#if CYTHON_REFNANNY - typedef struct { - void (*INCREF)(void*, PyObject*, Py_ssize_t); - void (*DECREF)(void*, PyObject*, Py_ssize_t); - void (*GOTREF)(void*, PyObject*, Py_ssize_t); - void (*GIVEREF)(void*, PyObject*, Py_ssize_t); - void* (*SetupContext)(const char*, Py_ssize_t, const char*); - void (*FinishContext)(void**); - } __Pyx_RefNannyAPIStruct; - static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; - static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); - #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; -#ifdef WITH_THREAD - #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - if (acquire_gil) {\ - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ - PyGILState_Release(__pyx_gilstate_save);\ - } else {\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ - } - #define __Pyx_RefNannyFinishContextNogil() {\ - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __Pyx_RefNannyFinishContext();\ - PyGILState_Release(__pyx_gilstate_save);\ - } -#else - #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) - #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() -#endif - #define __Pyx_RefNannyFinishContextNogil() {\ - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __Pyx_RefNannyFinishContext();\ - PyGILState_Release(__pyx_gilstate_save);\ - } - #define __Pyx_RefNannyFinishContext()\ - __Pyx_RefNanny->FinishContext(&__pyx_refnanny) - #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) - #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) - #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) - #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) - #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) - #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) - #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) - #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) -#else - #define __Pyx_RefNannyDeclarations - #define __Pyx_RefNannySetupContext(name, acquire_gil) - #define __Pyx_RefNannyFinishContextNogil() - #define __Pyx_RefNannyFinishContext() - #define __Pyx_INCREF(r) Py_INCREF(r) - #define __Pyx_DECREF(r) Py_DECREF(r) - #define __Pyx_GOTREF(r) - #define __Pyx_GIVEREF(r) - #define __Pyx_XINCREF(r) Py_XINCREF(r) - #define __Pyx_XDECREF(r) Py_XDECREF(r) - #define __Pyx_XGOTREF(r) - #define __Pyx_XGIVEREF(r) -#endif -#define __Pyx_Py_XDECREF_SET(r, v) do {\ - PyObject *tmp = (PyObject *) r;\ - r = v; Py_XDECREF(tmp);\ - } while (0) -#define __Pyx_XDECREF_SET(r, v) do {\ - PyObject *tmp = (PyObject *) r;\ - r = v; __Pyx_XDECREF(tmp);\ - } while (0) -#define __Pyx_DECREF_SET(r, v) do {\ - PyObject *tmp = (PyObject *) r;\ - r = v; __Pyx_DECREF(tmp);\ - } while (0) -#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) -#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) - -/* PyErrExceptionMatches.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) -static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); -#else -#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) -#endif - -/* PyThreadStateGet.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; -#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; -#if PY_VERSION_HEX >= 0x030C00A6 -#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) -#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) -#else -#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) -#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) -#endif -#else -#define __Pyx_PyThreadState_declare -#define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) -#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() -#endif - -/* PyErrFetchRestore.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) -#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 -#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) -#else -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#endif -#else -#define __Pyx_PyErr_Clear() PyErr_Clear() -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) -#endif - -/* PyObjectGetAttrStr.proto */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) -#endif - -/* PyObjectGetAttrStrNoError.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); - -/* GetBuiltinName.proto */ -static PyObject *__Pyx_GetBuiltinName(PyObject *name); - -/* TupleAndListFromArray.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); -static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); -#endif - -/* IncludeStringH.proto */ -#include - -/* BytesEquals.proto */ -static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); - -/* UnicodeEquals.proto */ -static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); - -/* fastcall.proto */ -#define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) -#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) -#define __Pyx_KwValues_VARARGS(args, nargs) NULL -#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) -#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) -#if CYTHON_METH_FASTCALL - #define __Pyx_Arg_FASTCALL(args, i) args[i] - #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds) - #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) - static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); - #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) -#else - #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS - #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS - #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS - #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS - #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS -#endif -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) -#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) -#else -#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) -#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) -#endif - -/* RaiseArgTupleInvalid.proto */ -static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, - Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); - -/* RaiseDoubleKeywords.proto */ -static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); - -/* ParseKeywords.proto */ -static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, - PyObject **argnames[], - PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, - const char* function_name); - -/* ArgTypeTest.proto */ -#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ - ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\ - __Pyx__ArgTypeTest(obj, type, name, exact)) -static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); - -/* RaiseException.proto */ -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); - -/* PyFunctionFastCall.proto */ -#if CYTHON_FAST_PYCALL -#if !CYTHON_VECTORCALL -#define __Pyx_PyFunction_FastCall(func, args, nargs)\ - __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) -static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); -#endif -#define __Pyx_BUILD_ASSERT_EXPR(cond)\ - (sizeof(char [1 - 2*!(cond)]) - 1) -#ifndef Py_MEMBER_SIZE -#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) -#endif -#if !CYTHON_VECTORCALL -#if PY_VERSION_HEX >= 0x03080000 - #include "frameobject.h" -#if PY_VERSION_HEX >= 0x030b00a6 - #ifndef Py_BUILD_CORE - #define Py_BUILD_CORE 1 - #endif - #include "internal/pycore_frame.h" -#endif - #define __Pxy_PyFrame_Initialize_Offsets() - #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) -#else - static size_t __pyx_pyframe_localsplus_offset = 0; - #include "frameobject.h" - #define __Pxy_PyFrame_Initialize_Offsets()\ - ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ - (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) - #define __Pyx_PyFrame_GetLocalsplus(frame)\ - (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) -#endif -#endif -#endif - -/* PyObjectCall.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); -#else -#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) -#endif - -/* PyObjectCallMethO.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); -#endif - -/* PyObjectFastCall.proto */ -#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) -static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs); - -/* RaiseUnexpectedTypeError.proto */ -static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); - -/* GCCDiagnostics.proto */ -#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) -#define __Pyx_HAS_GCC_DIAGNOSTIC -#endif - -/* BuildPyUnicode.proto */ -static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength, - int prepend_sign, char padding_char); - -/* CIntToPyUnicode.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char); - -/* CIntToPyUnicode.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char); - -/* JoinPyUnicode.proto */ -static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, - Py_UCS4 max_char); - -/* StrEquals.proto */ -#if PY_MAJOR_VERSION >= 3 -#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals -#else -#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals -#endif - -/* PyObjectFormatSimple.proto */ -#if CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyObject_FormatSimple(s, f) (\ - likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ - PyObject_Format(s, f)) -#elif PY_MAJOR_VERSION < 3 - #define __Pyx_PyObject_FormatSimple(s, f) (\ - likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ - likely(PyString_CheckExact(s)) ? PyUnicode_FromEncodedObject(s, NULL, "strict") :\ - PyObject_Format(s, f)) -#elif CYTHON_USE_TYPE_SLOTS - #define __Pyx_PyObject_FormatSimple(s, f) (\ - likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ - likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_repr(s) :\ - likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_repr(s) :\ - PyObject_Format(s, f)) -#else - #define __Pyx_PyObject_FormatSimple(s, f) (\ - likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ - PyObject_Format(s, f)) -#endif - -CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ -static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *); /*proto*/ -/* GetAttr.proto */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); - -/* GetItemInt.proto */ -#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ - (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ - __Pyx_GetItemInt_Generic(o, to_py_func(i)))) -#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ - (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, - int wraparound, int boundscheck); -#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ - (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, - int wraparound, int boundscheck); -static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, - int is_list, int wraparound, int boundscheck); - -/* PyObjectCallOneArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); - -/* ObjectGetItem.proto */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key); -#else -#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) -#endif - -/* KeywordStringCheck.proto */ -static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); - -/* DivInt[Py_ssize_t].proto */ -static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t, Py_ssize_t); - -/* UnaryNegOverflows.proto */ -#define __Pyx_UNARY_NEG_WOULD_OVERFLOW(x)\ - (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x))) - -/* GetAttr3.proto */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); - -/* PyDictVersioning.proto */ -#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS -#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) -#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) -#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ - (version_var) = __PYX_GET_DICT_VERSION(dict);\ - (cache_var) = (value); -#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ - static PY_UINT64_T __pyx_dict_version = 0;\ - static PyObject *__pyx_dict_cached_value = NULL;\ - if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ - (VAR) = __pyx_dict_cached_value;\ - } else {\ - (VAR) = __pyx_dict_cached_value = (LOOKUP);\ - __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ - }\ -} -static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); -static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); -static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); -#else -#define __PYX_GET_DICT_VERSION(dict) (0) -#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) -#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); -#endif - -/* GetModuleGlobalName.proto */ -#if CYTHON_USE_DICT_VERSIONS -#define __Pyx_GetModuleGlobalName(var, name) do {\ - static PY_UINT64_T __pyx_dict_version = 0;\ - static PyObject *__pyx_dict_cached_value = NULL;\ - (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ - (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ - __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} while(0) -#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ - PY_UINT64_T __pyx_dict_version;\ - PyObject *__pyx_dict_cached_value;\ - (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} while(0) -static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); -#else -#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) -#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) -static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); -#endif - -/* AssertionsEnabled.proto */ -#define __Pyx_init_assertions_enabled() -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) - #define __pyx_assertions_enabled() (1) -#elif PY_VERSION_HEX < 0x03080000 || CYTHON_COMPILING_IN_PYPY || defined(Py_LIMITED_API) - #define __pyx_assertions_enabled() (!Py_OptimizeFlag) -#elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030900A6 - static int __pyx_assertions_enabled_flag; - #define __pyx_assertions_enabled() (__pyx_assertions_enabled_flag) - #undef __Pyx_init_assertions_enabled - static void __Pyx_init_assertions_enabled(void) { - __pyx_assertions_enabled_flag = ! _PyInterpreterState_GetConfig(__Pyx_PyThreadState_Current->interp)->optimization_level; - } -#else - #define __pyx_assertions_enabled() (!Py_OptimizeFlag) -#endif - -/* RaiseTooManyValuesToUnpack.proto */ -static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); - -/* RaiseNeedMoreValuesToUnpack.proto */ -static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); - -/* RaiseNoneIterError.proto */ -static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); - -/* ExtTypeTest.proto */ -static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); - -/* GetTopmostException.proto */ -#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE -static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); -#endif - -/* SaveResetException.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); -#else -#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) -#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) -#endif - -/* GetException.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) -static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#else -static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); -#endif - -/* SwapException.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#else -static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); -#endif - -/* Import.proto */ -static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); - -/* ImportDottedModule.proto */ -static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple); -#if PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple); -#endif - -/* ssize_strlen.proto */ -static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); - -/* FastTypeChecks.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) -#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) -static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); -static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); -static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); -static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); -#else -#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) -#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) -#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) -#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) -#endif -#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) -#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) - -CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ -/* ListCompAppend.proto */ -#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS -static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { - PyListObject* L = (PyListObject*) list; - Py_ssize_t len = Py_SIZE(list); - if (likely(L->allocated > len)) { - Py_INCREF(x); - PyList_SET_ITEM(list, len, x); - __Pyx_SET_SIZE(list, len + 1); - return 0; - } - return PyList_Append(list, x); -} -#else -#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) -#endif - -/* PySequenceMultiply.proto */ -#define __Pyx_PySequence_Multiply_Left(mul, seq) __Pyx_PySequence_Multiply(seq, mul) -static CYTHON_INLINE PyObject* __Pyx_PySequence_Multiply(PyObject *seq, Py_ssize_t mul); - -/* SetItemInt.proto */ -#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\ - (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\ - __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) -static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); -static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, - int is_list, int wraparound, int boundscheck); - -/* RaiseUnboundLocalError.proto */ -static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); - -/* DivInt[long].proto */ -static CYTHON_INLINE long __Pyx_div_long(long, long); - -/* PySequenceContains.proto */ -static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { - int result = PySequence_Contains(seq, item); - return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); -} - -/* ImportFrom.proto */ -static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); - -/* HasAttr.proto */ -static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); - -/* ErrOccurredWithGIL.proto */ -static CYTHON_INLINE int __Pyx_ErrOccurredWithGIL(void); - -/* PyObject_GenericGetAttrNoDict.proto */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr -#endif - -/* PyObject_GenericGetAttr.proto */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr -#endif - -/* IncludeStructmemberH.proto */ -#include - -/* FixUpExtensionType.proto */ -#if CYTHON_USE_TYPE_SPECS -static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); -#endif - -/* PyObjectCallNoArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); - -/* PyObjectGetMethod.proto */ -static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); - -/* PyObjectCallMethod0.proto */ -static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); - -/* ValidateBasesTuple.proto */ -#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS -static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); -#endif - -/* PyType_Ready.proto */ -CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); - -/* SetVTable.proto */ -static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable); - -/* GetVTable.proto */ -static void* __Pyx_GetVtable(PyTypeObject *type); - -/* MergeVTables.proto */ -#if !CYTHON_COMPILING_IN_LIMITED_API -static int __Pyx_MergeVtables(PyTypeObject *type); -#endif - -/* SetupReduce.proto */ -#if !CYTHON_COMPILING_IN_LIMITED_API -static int __Pyx_setup_reduce(PyObject* type_obj); -#endif - -/* FetchSharedCythonModule.proto */ -static PyObject *__Pyx_FetchSharedCythonABIModule(void); - -/* FetchCommonType.proto */ -#if !CYTHON_USE_TYPE_SPECS -static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); -#else -static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); -#endif - -/* PyMethodNew.proto */ -#if PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { - CYTHON_UNUSED_VAR(typ); - if (!self) - return __Pyx_NewRef(func); - return PyMethod_New(func, self); -} -#else - #define __Pyx_PyMethod_New PyMethod_New -#endif - -/* PyVectorcallFastCallDict.proto */ -#if CYTHON_METH_FASTCALL -static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); -#endif - -/* CythonFunctionShared.proto */ -#define __Pyx_CyFunction_USED -#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 -#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 -#define __Pyx_CYFUNCTION_CCLASS 0x04 -#define __Pyx_CYFUNCTION_COROUTINE 0x08 -#define __Pyx_CyFunction_GetClosure(f)\ - (((__pyx_CyFunctionObject *) (f))->func_closure) -#if PY_VERSION_HEX < 0x030900B1 - #define __Pyx_CyFunction_GetClassObj(f)\ - (((__pyx_CyFunctionObject *) (f))->func_classobj) -#else - #define __Pyx_CyFunction_GetClassObj(f)\ - ((PyObject*) ((PyCMethodObject *) (f))->mm_class) -#endif -#define __Pyx_CyFunction_SetClassObj(f, classobj)\ - __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj)) -#define __Pyx_CyFunction_Defaults(type, f)\ - ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) -#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ - ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) -typedef struct { -#if PY_VERSION_HEX < 0x030900B1 - PyCFunctionObject func; -#else - PyCMethodObject func; -#endif -#if CYTHON_BACKPORT_VECTORCALL - __pyx_vectorcallfunc func_vectorcall; -#endif -#if PY_VERSION_HEX < 0x030500A0 - PyObject *func_weakreflist; -#endif - PyObject *func_dict; - PyObject *func_name; - PyObject *func_qualname; - PyObject *func_doc; - PyObject *func_globals; - PyObject *func_code; - PyObject *func_closure; -#if PY_VERSION_HEX < 0x030900B1 - PyObject *func_classobj; -#endif - void *defaults; - int defaults_pyobjects; - size_t defaults_size; // used by FusedFunction for copying defaults - int flags; - PyObject *defaults_tuple; - PyObject *defaults_kwdict; - PyObject *(*defaults_getter)(PyObject *); - PyObject *func_annotations; - PyObject *func_is_coroutine; -} __pyx_CyFunctionObject; -#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType) -#define __Pyx_IsCyOrPyCFunction(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) -#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) -static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, - int flags, PyObject* qualname, - PyObject *closure, - PyObject *module, PyObject *globals, - PyObject* code); -static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); -static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, - size_t size, - int pyobjects); -static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, - PyObject *tuple); -static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, - PyObject *dict); -static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, - PyObject *dict); -static int __pyx_CyFunction_init(PyObject *module); -#if CYTHON_METH_FASTCALL -static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -#if CYTHON_BACKPORT_VECTORCALL -#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) -#else -#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) -#endif -#endif - -/* CythonFunction.proto */ -static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, - int flags, PyObject* qualname, - PyObject *closure, - PyObject *module, PyObject *globals, - PyObject* code); - -/* CLineInTraceback.proto */ -#ifdef CYTHON_CLINE_IN_TRACEBACK -#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) -#else -static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); -#endif - -/* CodeObjectCache.proto */ -#if !CYTHON_COMPILING_IN_LIMITED_API -typedef struct { - PyCodeObject* code_object; - int code_line; -} __Pyx_CodeObjectCacheEntry; -struct __Pyx_CodeObjectCache { - int count; - int max_count; - __Pyx_CodeObjectCacheEntry* entries; -}; -static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; -static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); -static PyCodeObject *__pyx_find_code_object(int code_line); -static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); -#endif - -/* AddTraceback.proto */ -static void __Pyx_AddTraceback(const char *funcname, int c_line, - int py_line, const char *filename); - -#if PY_MAJOR_VERSION < 3 - static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); - static void __Pyx_ReleaseBuffer(Py_buffer *view); -#else - #define __Pyx_GetBuffer PyObject_GetBuffer - #define __Pyx_ReleaseBuffer PyBuffer_Release -#endif - - -/* BufferStructDeclare.proto */ -typedef struct { - Py_ssize_t shape, strides, suboffsets; -} __Pyx_Buf_DimInfo; -typedef struct { - size_t refcount; - Py_buffer pybuffer; -} __Pyx_Buffer; -typedef struct { - __Pyx_Buffer *rcbuffer; - char *data; - __Pyx_Buf_DimInfo diminfo[8]; -} __Pyx_LocalBuf_ND; - -/* MemviewSliceIsContig.proto */ -static int __pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim); - -/* OverlappingSlices.proto */ -static int __pyx_slices_overlap(__Pyx_memviewslice *slice1, - __Pyx_memviewslice *slice2, - int ndim, size_t itemsize); - -/* IsLittleEndian.proto */ -static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); - -/* BufferFormatCheck.proto */ -static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); -static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, - __Pyx_BufFmt_StackElem* stack, - __Pyx_TypeInfo* type); - -/* TypeInfoCompare.proto */ -static int __pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b); - -/* MemviewSliceValidateAndInit.proto */ -static int __Pyx_ValidateAndInit_memviewslice( - int *axes_specs, - int c_or_f_flag, - int buf_flags, - int ndim, - __Pyx_TypeInfo *dtype, - __Pyx_BufFmt_StackElem stack[], - __Pyx_memviewslice *memviewslice, - PyObject *original_obj); - -/* ObjectToMemviewSlice.proto */ -static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_int(PyObject *, int writable_flag); - -/* ObjectToMemviewSlice.proto */ -static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_float(PyObject *, int writable_flag); - -/* ObjectToMemviewSlice.proto */ -static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_int(PyObject *, int writable_flag); - -/* MemviewSliceCopyTemplate.proto */ -static __Pyx_memviewslice -__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, - const char *mode, int ndim, - size_t sizeof_dtype, int contig_flag, - int dtype_is_object); - -/* MemviewSliceInit.proto */ -#define __Pyx_BUF_MAX_NDIMS %(BUF_MAX_NDIMS)d -#define __Pyx_MEMVIEW_DIRECT 1 -#define __Pyx_MEMVIEW_PTR 2 -#define __Pyx_MEMVIEW_FULL 4 -#define __Pyx_MEMVIEW_CONTIG 8 -#define __Pyx_MEMVIEW_STRIDED 16 -#define __Pyx_MEMVIEW_FOLLOW 32 -#define __Pyx_IS_C_CONTIG 1 -#define __Pyx_IS_F_CONTIG 2 -static int __Pyx_init_memviewslice( - struct __pyx_memoryview_obj *memview, - int ndim, - __Pyx_memviewslice *memviewslice, - int memview_is_new_reference); -static CYTHON_INLINE int __pyx_add_acquisition_count_locked( - __pyx_atomic_int_type *acquisition_count, PyThread_type_lock lock); -static CYTHON_INLINE int __pyx_sub_acquisition_count_locked( - __pyx_atomic_int_type *acquisition_count, PyThread_type_lock lock); -#define __pyx_get_slice_count_pointer(memview) (&memview->acquisition_count) -#define __PYX_INC_MEMVIEW(slice, have_gil) __Pyx_INC_MEMVIEW(slice, have_gil, __LINE__) -#define __PYX_XCLEAR_MEMVIEW(slice, have_gil) __Pyx_XCLEAR_MEMVIEW(slice, have_gil, __LINE__) -static CYTHON_INLINE void __Pyx_INC_MEMVIEW(__Pyx_memviewslice *, int, int); -static CYTHON_INLINE void __Pyx_XCLEAR_MEMVIEW(__Pyx_memviewslice *, int, int); - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); - -/* CIntFromPy.proto */ -static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); - -/* CIntFromPy.proto */ -static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); - -/* CIntFromPy.proto */ -static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *); - -/* FormatTypeName.proto */ -#if CYTHON_COMPILING_IN_LIMITED_API -typedef PyObject *__Pyx_TypeName; -#define __Pyx_FMT_TYPENAME "%U" -static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); -#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) -#else -typedef const char *__Pyx_TypeName; -#define __Pyx_FMT_TYPENAME "%.200s" -#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) -#define __Pyx_DECREF_TypeName(obj) -#endif - -/* CheckBinaryVersion.proto */ -static int __Pyx_check_binary_version(void); - -/* InitStrings.proto */ -static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); - -/* #### Code section: module_declarations ### */ -static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self); /* proto*/ -static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto*/ -static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj); /* proto*/ -static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src); /* proto*/ -static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value); /* proto*/ -static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto*/ -static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/ -static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/ -static PyObject *__pyx_memoryview__get_base(struct __pyx_memoryview_obj *__pyx_v_self); /* proto*/ -static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/ -static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/ -static PyObject *__pyx_memoryviewslice__get_base(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto*/ - -/* Module declarations from "cython.view" */ - -/* Module declarations from "cython.dataclasses" */ - -/* Module declarations from "cython" */ - -/* Module declarations from "monotonic_align.core" */ -static PyObject *__pyx_collections_abc_Sequence = 0; -static PyObject *generic = 0; -static PyObject *strided = 0; -static PyObject *indirect = 0; -static PyObject *contiguous = 0; -static PyObject *indirect_contiguous = 0; -static int __pyx_memoryview_thread_locks_used; -static PyThread_type_lock __pyx_memoryview_thread_locks[8]; -static void __pyx_f_15monotonic_align_4core_maximum_path_each(__Pyx_memviewslice, __Pyx_memviewslice, int, int, struct __pyx_opt_args_15monotonic_align_4core_maximum_path_each *__pyx_optional_args); /*proto*/ -static void __pyx_f_15monotonic_align_4core_maximum_path_c(__Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, int __pyx_skip_dispatch); /*proto*/ -static int __pyx_array_allocate_buffer(struct __pyx_array_obj *); /*proto*/ -static struct __pyx_array_obj *__pyx_array_new(PyObject *, Py_ssize_t, char *, char *, char *); /*proto*/ -static PyObject *__pyx_memoryview_new(PyObject *, int, int, __Pyx_TypeInfo *); /*proto*/ -static CYTHON_INLINE int __pyx_memoryview_check(PyObject *); /*proto*/ -static PyObject *_unellipsify(PyObject *, int); /*proto*/ -static int assert_direct_dimensions(Py_ssize_t *, int); /*proto*/ -static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *, PyObject *); /*proto*/ -static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int, int); /*proto*/ -static char *__pyx_pybuffer_index(Py_buffer *, char *, Py_ssize_t, Py_ssize_t); /*proto*/ -static int __pyx_memslice_transpose(__Pyx_memviewslice *); /*proto*/ -static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice, int, PyObject *(*)(char *), int (*)(char *, PyObject *), int); /*proto*/ -static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ -static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ -static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *); /*proto*/ -static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ -static Py_ssize_t abs_py_ssize_t(Py_ssize_t); /*proto*/ -static char __pyx_get_best_slice_order(__Pyx_memviewslice *, int); /*proto*/ -static void _copy_strided_to_strided(char *, Py_ssize_t *, char *, Py_ssize_t *, Py_ssize_t *, Py_ssize_t *, int, size_t); /*proto*/ -static void copy_strided_to_strided(__Pyx_memviewslice *, __Pyx_memviewslice *, int, size_t); /*proto*/ -static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *, int); /*proto*/ -static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *, Py_ssize_t *, Py_ssize_t, int, char); /*proto*/ -static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *, __Pyx_memviewslice *, char, int); /*proto*/ -static int __pyx_memoryview_err_extents(int, Py_ssize_t, Py_ssize_t); /*proto*/ -static int __pyx_memoryview_err_dim(PyObject *, PyObject *, int); /*proto*/ -static int __pyx_memoryview_err(PyObject *, PyObject *); /*proto*/ -static int __pyx_memoryview_err_no_memory(void); /*proto*/ -static int __pyx_memoryview_copy_contents(__Pyx_memviewslice, __Pyx_memviewslice, int, int, int); /*proto*/ -static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *, int, int); /*proto*/ -static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *, int, int, int); /*proto*/ -static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/ -static void __pyx_memoryview_refcount_objects_in_slice(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/ -static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *, int, size_t, void *, int); /*proto*/ -static void __pyx_memoryview__slice_assign_scalar(char *, Py_ssize_t *, Py_ssize_t *, int, size_t, void *); /*proto*/ -static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *, PyObject *); /*proto*/ -/* #### Code section: typeinfo ### */ -static __Pyx_TypeInfo __Pyx_TypeInfo_int = { "int", NULL, sizeof(int), { 0 }, 0, __PYX_IS_UNSIGNED(int) ? 'U' : 'I', __PYX_IS_UNSIGNED(int), 0 }; -static __Pyx_TypeInfo __Pyx_TypeInfo_float = { "float", NULL, sizeof(float), { 0 }, 0, 'R', 0, 0 }; -/* #### Code section: before_global_var ### */ -#define __Pyx_MODULE_NAME "monotonic_align.core" -extern int __pyx_module_is_main_monotonic_align__core; -int __pyx_module_is_main_monotonic_align__core = 0; - -/* Implementation of "monotonic_align.core" */ -/* #### Code section: global_var ### */ -static PyObject *__pyx_builtin_range; -static PyObject *__pyx_builtin___import__; -static PyObject *__pyx_builtin_ValueError; -static PyObject *__pyx_builtin_MemoryError; -static PyObject *__pyx_builtin_enumerate; -static PyObject *__pyx_builtin_TypeError; -static PyObject *__pyx_builtin_AssertionError; -static PyObject *__pyx_builtin_Ellipsis; -static PyObject *__pyx_builtin_id; -static PyObject *__pyx_builtin_IndexError; -/* #### Code section: string_decls ### */ -static const char __pyx_k_[] = ": "; -static const char __pyx_k_O[] = "O"; -static const char __pyx_k_c[] = "c"; -static const char __pyx_k__2[] = "."; -static const char __pyx_k__3[] = "*"; -static const char __pyx_k__6[] = "'"; -static const char __pyx_k__7[] = ")"; -static const char __pyx_k_gc[] = "gc"; -static const char __pyx_k_id[] = "id"; -static const char __pyx_k__23[] = "?"; -static const char __pyx_k_abc[] = "abc"; -static const char __pyx_k_and[] = " and "; -static const char __pyx_k_got[] = " (got "; -static const char __pyx_k_new[] = "__new__"; -static const char __pyx_k_obj[] = "obj"; -static const char __pyx_k_sys[] = "sys"; -static const char __pyx_k_base[] = "base"; -static const char __pyx_k_dict[] = "__dict__"; -static const char __pyx_k_main[] = "__main__"; -static const char __pyx_k_mode[] = "mode"; -static const char __pyx_k_name[] = "name"; -static const char __pyx_k_ndim[] = "ndim"; -static const char __pyx_k_pack[] = "pack"; -static const char __pyx_k_size[] = "size"; -static const char __pyx_k_spec[] = "__spec__"; -static const char __pyx_k_step[] = "step"; -static const char __pyx_k_stop[] = "stop"; -static const char __pyx_k_t_xs[] = "t_xs"; -static const char __pyx_k_t_ys[] = "t_ys"; -static const char __pyx_k_test[] = "__test__"; -static const char __pyx_k_ASCII[] = "ASCII"; -static const char __pyx_k_class[] = "__class__"; -static const char __pyx_k_count[] = "count"; -static const char __pyx_k_error[] = "error"; -static const char __pyx_k_flags[] = "flags"; -static const char __pyx_k_index[] = "index"; -static const char __pyx_k_paths[] = "paths"; -static const char __pyx_k_range[] = "range"; -static const char __pyx_k_shape[] = "shape"; -static const char __pyx_k_start[] = "start"; -static const char __pyx_k_enable[] = "enable"; -static const char __pyx_k_encode[] = "encode"; -static const char __pyx_k_format[] = "format"; -static const char __pyx_k_import[] = "__import__"; -static const char __pyx_k_name_2[] = "__name__"; -static const char __pyx_k_pickle[] = "pickle"; -static const char __pyx_k_reduce[] = "__reduce__"; -static const char __pyx_k_struct[] = "struct"; -static const char __pyx_k_unpack[] = "unpack"; -static const char __pyx_k_update[] = "update"; -static const char __pyx_k_values[] = "values"; -static const char __pyx_k_disable[] = "disable"; -static const char __pyx_k_fortran[] = "fortran"; -static const char __pyx_k_memview[] = "memview"; -static const char __pyx_k_Ellipsis[] = "Ellipsis"; -static const char __pyx_k_Sequence[] = "Sequence"; -static const char __pyx_k_core_pyx[] = "core.pyx"; -static const char __pyx_k_getstate[] = "__getstate__"; -static const char __pyx_k_itemsize[] = "itemsize"; -static const char __pyx_k_pyx_type[] = "__pyx_type"; -static const char __pyx_k_register[] = "register"; -static const char __pyx_k_setstate[] = "__setstate__"; -static const char __pyx_k_TypeError[] = "TypeError"; -static const char __pyx_k_enumerate[] = "enumerate"; -static const char __pyx_k_isenabled[] = "isenabled"; -static const char __pyx_k_pyx_state[] = "__pyx_state"; -static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; -static const char __pyx_k_IndexError[] = "IndexError"; -static const char __pyx_k_ValueError[] = "ValueError"; -static const char __pyx_k_pyx_result[] = "__pyx_result"; -static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; -static const char __pyx_k_MemoryError[] = "MemoryError"; -static const char __pyx_k_PickleError[] = "PickleError"; -static const char __pyx_k_collections[] = "collections"; -static const char __pyx_k_initializing[] = "_initializing"; -static const char __pyx_k_is_coroutine[] = "_is_coroutine"; -static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; -static const char __pyx_k_stringsource[] = " "; -static const char __pyx_k_version_info[] = "version_info"; -static const char __pyx_k_class_getitem[] = "__class_getitem__"; -static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; -static const char __pyx_k_AssertionError[] = "AssertionError"; -static const char __pyx_k_maximum_path_c[] = "maximum_path_c"; -static const char __pyx_k_View_MemoryView[] = "View.MemoryView"; -static const char __pyx_k_allocate_buffer[] = "allocate_buffer"; -static const char __pyx_k_collections_abc[] = "collections.abc"; -static const char __pyx_k_dtype_is_object[] = "dtype_is_object"; -static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError"; -static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; -static const char __pyx_k_pyx_unpickle_Enum[] = "__pyx_unpickle_Enum"; -static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines"; -static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; -static const char __pyx_k_strided_and_direct[] = " "; -static const char __pyx_k_monotonic_align_core[] = "monotonic_align.core"; -static const char __pyx_k_strided_and_indirect[] = " "; -static const char __pyx_k_Invalid_shape_in_axis[] = "Invalid shape in axis "; -static const char __pyx_k_contiguous_and_direct[] = " "; -static const char __pyx_k_Cannot_index_with_type[] = "Cannot index with type '"; -static const char __pyx_k_MemoryView_of_r_object[] = " "; -static const char __pyx_k_MemoryView_of_r_at_0x_x[] = " "; -static const char __pyx_k_contiguous_and_indirect[] = " "; -static const char __pyx_k_Dimension_d_is_not_direct[] = "Dimension %d is not direct"; -static const char __pyx_k_Index_out_of_bounds_axis_d[] = "Index out of bounds (axis %d)"; -static const char __pyx_k_Step_may_not_be_zero_axis_d[] = "Step may not be zero (axis %d)"; -static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array"; -static const char __pyx_k_unable_to_allocate_array_data[] = "unable to allocate array data."; -static const char __pyx_k_strided_and_direct_or_indirect[] = " "; -static const char __pyx_k_All_dimensions_preceding_dimensi[] = "All dimensions preceding dimension %d must be indexed and not sliced"; -static const char __pyx_k_Buffer_view_does_not_expose_stri[] = "Buffer view does not expose strides"; -static const char __pyx_k_Can_only_create_a_buffer_that_is[] = "Can only create a buffer that is contiguous in memory."; -static const char __pyx_k_Cannot_assign_to_read_only_memor[] = "Cannot assign to read-only memoryview"; -static const char __pyx_k_Cannot_create_writable_memory_vi[] = "Cannot create writable memory view from read-only memoryview"; -static const char __pyx_k_Cannot_transpose_memoryview_with[] = "Cannot transpose memoryview with indirect dimensions"; -static const char __pyx_k_Empty_shape_tuple_for_cython_arr[] = "Empty shape tuple for cython.array"; -static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))"; -static const char __pyx_k_Indirect_dimensions_not_supporte[] = "Indirect dimensions not supported"; -static const char __pyx_k_Invalid_mode_expected_c_or_fortr[] = "Invalid mode, expected 'c' or 'fortran', got "; -static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis "; -static const char __pyx_k_Unable_to_convert_item_to_object[] = "Unable to convert item to object"; -static const char __pyx_k_got_differing_extents_in_dimensi[] = "got differing extents in dimension "; -static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; -static const char __pyx_k_unable_to_allocate_shape_and_str[] = "unable to allocate shape and strides."; -/* #### Code section: decls ### */ -static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer); /* proto */ -static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ -static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self); /* proto */ -static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr); /* proto */ -static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item); /* proto */ -static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /* proto */ -static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ -static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ -static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ -static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object); /* proto */ -static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto */ -static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto */ -static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ -static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ -static PyObject *__pyx_pf_15monotonic_align_4core_maximum_path_c(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_paths, __Pyx_memviewslice __pyx_v_values, __Pyx_memviewslice __pyx_v_t_ys, __Pyx_memviewslice __pyx_v_t_xs); /* proto */ -static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -/* #### Code section: late_includes ### */ -/* #### Code section: module_state ### */ -typedef struct { - PyObject *__pyx_d; - PyObject *__pyx_b; - PyObject *__pyx_cython_runtime; - PyObject *__pyx_empty_tuple; - PyObject *__pyx_empty_bytes; - PyObject *__pyx_empty_unicode; - #ifdef __Pyx_CyFunction_USED - PyTypeObject *__pyx_CyFunctionType; - #endif - #ifdef __Pyx_FusedFunction_USED - PyTypeObject *__pyx_FusedFunctionType; - #endif - #ifdef __Pyx_Generator_USED - PyTypeObject *__pyx_GeneratorType; - #endif - #ifdef __Pyx_IterableCoroutine_USED - PyTypeObject *__pyx_IterableCoroutineType; - #endif - #ifdef __Pyx_Coroutine_USED - PyTypeObject *__pyx_CoroutineAwaitType; - #endif - #ifdef __Pyx_Coroutine_USED - PyTypeObject *__pyx_CoroutineType; - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - PyObject *__pyx_type___pyx_array; - PyObject *__pyx_type___pyx_MemviewEnum; - PyObject *__pyx_type___pyx_memoryview; - PyObject *__pyx_type___pyx_memoryviewslice; - #endif - PyTypeObject *__pyx_array_type; - PyTypeObject *__pyx_MemviewEnum_type; - PyTypeObject *__pyx_memoryview_type; - PyTypeObject *__pyx_memoryviewslice_type; - PyObject *__pyx_kp_u_; - PyObject *__pyx_n_s_ASCII; - PyObject *__pyx_kp_s_All_dimensions_preceding_dimensi; - PyObject *__pyx_n_s_AssertionError; - PyObject *__pyx_kp_s_Buffer_view_does_not_expose_stri; - PyObject *__pyx_kp_s_Can_only_create_a_buffer_that_is; - PyObject *__pyx_kp_s_Cannot_assign_to_read_only_memor; - PyObject *__pyx_kp_s_Cannot_create_writable_memory_vi; - PyObject *__pyx_kp_u_Cannot_index_with_type; - PyObject *__pyx_kp_s_Cannot_transpose_memoryview_with; - PyObject *__pyx_kp_s_Dimension_d_is_not_direct; - PyObject *__pyx_n_s_Ellipsis; - PyObject *__pyx_kp_s_Empty_shape_tuple_for_cython_arr; - PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; - PyObject *__pyx_n_s_IndexError; - PyObject *__pyx_kp_s_Index_out_of_bounds_axis_d; - PyObject *__pyx_kp_s_Indirect_dimensions_not_supporte; - PyObject *__pyx_kp_u_Invalid_mode_expected_c_or_fortr; - PyObject *__pyx_kp_u_Invalid_shape_in_axis; - PyObject *__pyx_n_s_MemoryError; - PyObject *__pyx_kp_s_MemoryView_of_r_at_0x_x; - PyObject *__pyx_kp_s_MemoryView_of_r_object; - PyObject *__pyx_n_b_O; - PyObject *__pyx_kp_u_Out_of_bounds_on_buffer_access_a; - PyObject *__pyx_n_s_PickleError; - PyObject *__pyx_n_s_Sequence; - PyObject *__pyx_kp_s_Step_may_not_be_zero_axis_d; - PyObject *__pyx_n_s_TypeError; - PyObject *__pyx_kp_s_Unable_to_convert_item_to_object; - PyObject *__pyx_n_s_ValueError; - PyObject *__pyx_n_s_View_MemoryView; - PyObject *__pyx_kp_u__2; - PyObject *__pyx_n_s__23; - PyObject *__pyx_n_s__3; - PyObject *__pyx_kp_u__6; - PyObject *__pyx_kp_u__7; - PyObject *__pyx_n_s_abc; - PyObject *__pyx_n_s_allocate_buffer; - PyObject *__pyx_kp_u_and; - PyObject *__pyx_n_s_asyncio_coroutines; - PyObject *__pyx_n_s_base; - PyObject *__pyx_n_s_c; - PyObject *__pyx_n_u_c; - PyObject *__pyx_n_s_class; - PyObject *__pyx_n_s_class_getitem; - PyObject *__pyx_n_s_cline_in_traceback; - PyObject *__pyx_n_s_collections; - PyObject *__pyx_kp_s_collections_abc; - PyObject *__pyx_kp_s_contiguous_and_direct; - PyObject *__pyx_kp_s_contiguous_and_indirect; - PyObject *__pyx_kp_s_core_pyx; - PyObject *__pyx_n_s_count; - PyObject *__pyx_n_s_dict; - PyObject *__pyx_kp_u_disable; - PyObject *__pyx_n_s_dtype_is_object; - PyObject *__pyx_kp_u_enable; - PyObject *__pyx_n_s_encode; - PyObject *__pyx_n_s_enumerate; - PyObject *__pyx_n_s_error; - PyObject *__pyx_n_s_flags; - PyObject *__pyx_n_s_format; - PyObject *__pyx_n_s_fortran; - PyObject *__pyx_n_u_fortran; - PyObject *__pyx_kp_u_gc; - PyObject *__pyx_n_s_getstate; - PyObject *__pyx_kp_u_got; - PyObject *__pyx_kp_u_got_differing_extents_in_dimensi; - PyObject *__pyx_n_s_id; - PyObject *__pyx_n_s_import; - PyObject *__pyx_n_s_index; - PyObject *__pyx_n_s_initializing; - PyObject *__pyx_n_s_is_coroutine; - PyObject *__pyx_kp_u_isenabled; - PyObject *__pyx_n_s_itemsize; - PyObject *__pyx_kp_s_itemsize_0_for_cython_array; - PyObject *__pyx_n_s_main; - PyObject *__pyx_n_s_maximum_path_c; - PyObject *__pyx_n_s_memview; - PyObject *__pyx_n_s_mode; - PyObject *__pyx_n_s_monotonic_align_core; - PyObject *__pyx_n_s_name; - PyObject *__pyx_n_s_name_2; - PyObject *__pyx_n_s_ndim; - PyObject *__pyx_n_s_new; - PyObject *__pyx_kp_s_no_default___reduce___due_to_non; - PyObject *__pyx_n_s_obj; - PyObject *__pyx_n_s_pack; - PyObject *__pyx_n_s_paths; - PyObject *__pyx_n_s_pickle; - PyObject *__pyx_n_s_pyx_PickleError; - PyObject *__pyx_n_s_pyx_checksum; - PyObject *__pyx_n_s_pyx_result; - PyObject *__pyx_n_s_pyx_state; - PyObject *__pyx_n_s_pyx_type; - PyObject *__pyx_n_s_pyx_unpickle_Enum; - PyObject *__pyx_n_s_pyx_vtable; - PyObject *__pyx_n_s_range; - PyObject *__pyx_n_s_reduce; - PyObject *__pyx_n_s_reduce_cython; - PyObject *__pyx_n_s_reduce_ex; - PyObject *__pyx_n_s_register; - PyObject *__pyx_n_s_setstate; - PyObject *__pyx_n_s_setstate_cython; - PyObject *__pyx_n_s_shape; - PyObject *__pyx_n_s_size; - PyObject *__pyx_n_s_spec; - PyObject *__pyx_n_s_start; - PyObject *__pyx_n_s_step; - PyObject *__pyx_n_s_stop; - PyObject *__pyx_kp_s_strided_and_direct; - PyObject *__pyx_kp_s_strided_and_direct_or_indirect; - PyObject *__pyx_kp_s_strided_and_indirect; - PyObject *__pyx_kp_s_stringsource; - PyObject *__pyx_n_s_struct; - PyObject *__pyx_n_s_sys; - PyObject *__pyx_n_s_t_xs; - PyObject *__pyx_n_s_t_ys; - PyObject *__pyx_n_s_test; - PyObject *__pyx_kp_s_unable_to_allocate_array_data; - PyObject *__pyx_kp_s_unable_to_allocate_shape_and_str; - PyObject *__pyx_n_s_unpack; - PyObject *__pyx_n_s_update; - PyObject *__pyx_n_s_values; - PyObject *__pyx_n_s_version_info; - PyObject *__pyx_int_0; - PyObject *__pyx_int_1; - PyObject *__pyx_int_3; - PyObject *__pyx_int_112105877; - PyObject *__pyx_int_136983863; - PyObject *__pyx_int_184977713; - PyObject *__pyx_int_neg_1; - float __pyx_k__9; - PyObject *__pyx_slice__5; - PyObject *__pyx_tuple__4; - PyObject *__pyx_tuple__8; - PyObject *__pyx_tuple__10; - PyObject *__pyx_tuple__11; - PyObject *__pyx_tuple__12; - PyObject *__pyx_tuple__13; - PyObject *__pyx_tuple__14; - PyObject *__pyx_tuple__15; - PyObject *__pyx_tuple__16; - PyObject *__pyx_tuple__17; - PyObject *__pyx_tuple__18; - PyObject *__pyx_tuple__19; - PyObject *__pyx_tuple__21; - PyObject *__pyx_codeobj__20; - PyObject *__pyx_codeobj__22; -} __pyx_mstate; - -#if CYTHON_USE_MODULE_STATE -#ifdef __cplusplus -namespace { - extern struct PyModuleDef __pyx_moduledef; -} /* anonymous namespace */ -#else -static struct PyModuleDef __pyx_moduledef; -#endif - -#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) - -#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) - -#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) -#else -static __pyx_mstate __pyx_mstate_global_static = -#ifdef __cplusplus - {}; -#else - {0}; -#endif -static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; -#endif -/* #### Code section: module_state_clear ### */ -#if CYTHON_USE_MODULE_STATE -static int __pyx_m_clear(PyObject *m) { - __pyx_mstate *clear_module_state = __pyx_mstate(m); - if (!clear_module_state) return 0; - Py_CLEAR(clear_module_state->__pyx_d); - Py_CLEAR(clear_module_state->__pyx_b); - Py_CLEAR(clear_module_state->__pyx_cython_runtime); - Py_CLEAR(clear_module_state->__pyx_empty_tuple); - Py_CLEAR(clear_module_state->__pyx_empty_bytes); - Py_CLEAR(clear_module_state->__pyx_empty_unicode); - #ifdef __Pyx_CyFunction_USED - Py_CLEAR(clear_module_state->__pyx_CyFunctionType); - #endif - #ifdef __Pyx_FusedFunction_USED - Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); - #endif - Py_CLEAR(clear_module_state->__pyx_array_type); - Py_CLEAR(clear_module_state->__pyx_type___pyx_array); - Py_CLEAR(clear_module_state->__pyx_MemviewEnum_type); - Py_CLEAR(clear_module_state->__pyx_type___pyx_MemviewEnum); - Py_CLEAR(clear_module_state->__pyx_memoryview_type); - Py_CLEAR(clear_module_state->__pyx_type___pyx_memoryview); - Py_CLEAR(clear_module_state->__pyx_memoryviewslice_type); - Py_CLEAR(clear_module_state->__pyx_type___pyx_memoryviewslice); - Py_CLEAR(clear_module_state->__pyx_kp_u_); - Py_CLEAR(clear_module_state->__pyx_n_s_ASCII); - Py_CLEAR(clear_module_state->__pyx_kp_s_All_dimensions_preceding_dimensi); - Py_CLEAR(clear_module_state->__pyx_n_s_AssertionError); - Py_CLEAR(clear_module_state->__pyx_kp_s_Buffer_view_does_not_expose_stri); - Py_CLEAR(clear_module_state->__pyx_kp_s_Can_only_create_a_buffer_that_is); - Py_CLEAR(clear_module_state->__pyx_kp_s_Cannot_assign_to_read_only_memor); - Py_CLEAR(clear_module_state->__pyx_kp_s_Cannot_create_writable_memory_vi); - Py_CLEAR(clear_module_state->__pyx_kp_u_Cannot_index_with_type); - Py_CLEAR(clear_module_state->__pyx_kp_s_Cannot_transpose_memoryview_with); - Py_CLEAR(clear_module_state->__pyx_kp_s_Dimension_d_is_not_direct); - Py_CLEAR(clear_module_state->__pyx_n_s_Ellipsis); - Py_CLEAR(clear_module_state->__pyx_kp_s_Empty_shape_tuple_for_cython_arr); - Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); - Py_CLEAR(clear_module_state->__pyx_n_s_IndexError); - Py_CLEAR(clear_module_state->__pyx_kp_s_Index_out_of_bounds_axis_d); - Py_CLEAR(clear_module_state->__pyx_kp_s_Indirect_dimensions_not_supporte); - Py_CLEAR(clear_module_state->__pyx_kp_u_Invalid_mode_expected_c_or_fortr); - Py_CLEAR(clear_module_state->__pyx_kp_u_Invalid_shape_in_axis); - Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError); - Py_CLEAR(clear_module_state->__pyx_kp_s_MemoryView_of_r_at_0x_x); - Py_CLEAR(clear_module_state->__pyx_kp_s_MemoryView_of_r_object); - Py_CLEAR(clear_module_state->__pyx_n_b_O); - Py_CLEAR(clear_module_state->__pyx_kp_u_Out_of_bounds_on_buffer_access_a); - Py_CLEAR(clear_module_state->__pyx_n_s_PickleError); - Py_CLEAR(clear_module_state->__pyx_n_s_Sequence); - Py_CLEAR(clear_module_state->__pyx_kp_s_Step_may_not_be_zero_axis_d); - Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); - Py_CLEAR(clear_module_state->__pyx_kp_s_Unable_to_convert_item_to_object); - Py_CLEAR(clear_module_state->__pyx_n_s_ValueError); - Py_CLEAR(clear_module_state->__pyx_n_s_View_MemoryView); - Py_CLEAR(clear_module_state->__pyx_kp_u__2); - Py_CLEAR(clear_module_state->__pyx_n_s__23); - Py_CLEAR(clear_module_state->__pyx_n_s__3); - Py_CLEAR(clear_module_state->__pyx_kp_u__6); - Py_CLEAR(clear_module_state->__pyx_kp_u__7); - Py_CLEAR(clear_module_state->__pyx_n_s_abc); - Py_CLEAR(clear_module_state->__pyx_n_s_allocate_buffer); - Py_CLEAR(clear_module_state->__pyx_kp_u_and); - Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); - Py_CLEAR(clear_module_state->__pyx_n_s_base); - Py_CLEAR(clear_module_state->__pyx_n_s_c); - Py_CLEAR(clear_module_state->__pyx_n_u_c); - Py_CLEAR(clear_module_state->__pyx_n_s_class); - Py_CLEAR(clear_module_state->__pyx_n_s_class_getitem); - Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); - Py_CLEAR(clear_module_state->__pyx_n_s_collections); - Py_CLEAR(clear_module_state->__pyx_kp_s_collections_abc); - Py_CLEAR(clear_module_state->__pyx_kp_s_contiguous_and_direct); - Py_CLEAR(clear_module_state->__pyx_kp_s_contiguous_and_indirect); - Py_CLEAR(clear_module_state->__pyx_kp_s_core_pyx); - Py_CLEAR(clear_module_state->__pyx_n_s_count); - Py_CLEAR(clear_module_state->__pyx_n_s_dict); - Py_CLEAR(clear_module_state->__pyx_kp_u_disable); - Py_CLEAR(clear_module_state->__pyx_n_s_dtype_is_object); - Py_CLEAR(clear_module_state->__pyx_kp_u_enable); - Py_CLEAR(clear_module_state->__pyx_n_s_encode); - Py_CLEAR(clear_module_state->__pyx_n_s_enumerate); - Py_CLEAR(clear_module_state->__pyx_n_s_error); - Py_CLEAR(clear_module_state->__pyx_n_s_flags); - Py_CLEAR(clear_module_state->__pyx_n_s_format); - Py_CLEAR(clear_module_state->__pyx_n_s_fortran); - Py_CLEAR(clear_module_state->__pyx_n_u_fortran); - Py_CLEAR(clear_module_state->__pyx_kp_u_gc); - Py_CLEAR(clear_module_state->__pyx_n_s_getstate); - Py_CLEAR(clear_module_state->__pyx_kp_u_got); - Py_CLEAR(clear_module_state->__pyx_kp_u_got_differing_extents_in_dimensi); - Py_CLEAR(clear_module_state->__pyx_n_s_id); - Py_CLEAR(clear_module_state->__pyx_n_s_import); - Py_CLEAR(clear_module_state->__pyx_n_s_index); - Py_CLEAR(clear_module_state->__pyx_n_s_initializing); - Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); - Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); - Py_CLEAR(clear_module_state->__pyx_n_s_itemsize); - Py_CLEAR(clear_module_state->__pyx_kp_s_itemsize_0_for_cython_array); - Py_CLEAR(clear_module_state->__pyx_n_s_main); - Py_CLEAR(clear_module_state->__pyx_n_s_maximum_path_c); - Py_CLEAR(clear_module_state->__pyx_n_s_memview); - Py_CLEAR(clear_module_state->__pyx_n_s_mode); - Py_CLEAR(clear_module_state->__pyx_n_s_monotonic_align_core); - Py_CLEAR(clear_module_state->__pyx_n_s_name); - Py_CLEAR(clear_module_state->__pyx_n_s_name_2); - Py_CLEAR(clear_module_state->__pyx_n_s_ndim); - Py_CLEAR(clear_module_state->__pyx_n_s_new); - Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non); - Py_CLEAR(clear_module_state->__pyx_n_s_obj); - Py_CLEAR(clear_module_state->__pyx_n_s_pack); - Py_CLEAR(clear_module_state->__pyx_n_s_paths); - Py_CLEAR(clear_module_state->__pyx_n_s_pickle); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_PickleError); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_checksum); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_result); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_type); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Enum); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_vtable); - Py_CLEAR(clear_module_state->__pyx_n_s_range); - Py_CLEAR(clear_module_state->__pyx_n_s_reduce); - Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); - Py_CLEAR(clear_module_state->__pyx_n_s_register); - Py_CLEAR(clear_module_state->__pyx_n_s_setstate); - Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_shape); - Py_CLEAR(clear_module_state->__pyx_n_s_size); - Py_CLEAR(clear_module_state->__pyx_n_s_spec); - Py_CLEAR(clear_module_state->__pyx_n_s_start); - Py_CLEAR(clear_module_state->__pyx_n_s_step); - Py_CLEAR(clear_module_state->__pyx_n_s_stop); - Py_CLEAR(clear_module_state->__pyx_kp_s_strided_and_direct); - Py_CLEAR(clear_module_state->__pyx_kp_s_strided_and_direct_or_indirect); - Py_CLEAR(clear_module_state->__pyx_kp_s_strided_and_indirect); - Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); - Py_CLEAR(clear_module_state->__pyx_n_s_struct); - Py_CLEAR(clear_module_state->__pyx_n_s_sys); - Py_CLEAR(clear_module_state->__pyx_n_s_t_xs); - Py_CLEAR(clear_module_state->__pyx_n_s_t_ys); - Py_CLEAR(clear_module_state->__pyx_n_s_test); - Py_CLEAR(clear_module_state->__pyx_kp_s_unable_to_allocate_array_data); - Py_CLEAR(clear_module_state->__pyx_kp_s_unable_to_allocate_shape_and_str); - Py_CLEAR(clear_module_state->__pyx_n_s_unpack); - Py_CLEAR(clear_module_state->__pyx_n_s_update); - Py_CLEAR(clear_module_state->__pyx_n_s_values); - Py_CLEAR(clear_module_state->__pyx_n_s_version_info); - Py_CLEAR(clear_module_state->__pyx_int_0); - Py_CLEAR(clear_module_state->__pyx_int_1); - Py_CLEAR(clear_module_state->__pyx_int_3); - Py_CLEAR(clear_module_state->__pyx_int_112105877); - Py_CLEAR(clear_module_state->__pyx_int_136983863); - Py_CLEAR(clear_module_state->__pyx_int_184977713); - Py_CLEAR(clear_module_state->__pyx_int_neg_1); - Py_CLEAR(clear_module_state->__pyx_slice__5); - Py_CLEAR(clear_module_state->__pyx_tuple__4); - Py_CLEAR(clear_module_state->__pyx_tuple__8); - Py_CLEAR(clear_module_state->__pyx_tuple__10); - Py_CLEAR(clear_module_state->__pyx_tuple__11); - Py_CLEAR(clear_module_state->__pyx_tuple__12); - Py_CLEAR(clear_module_state->__pyx_tuple__13); - Py_CLEAR(clear_module_state->__pyx_tuple__14); - Py_CLEAR(clear_module_state->__pyx_tuple__15); - Py_CLEAR(clear_module_state->__pyx_tuple__16); - Py_CLEAR(clear_module_state->__pyx_tuple__17); - Py_CLEAR(clear_module_state->__pyx_tuple__18); - Py_CLEAR(clear_module_state->__pyx_tuple__19); - Py_CLEAR(clear_module_state->__pyx_tuple__21); - Py_CLEAR(clear_module_state->__pyx_codeobj__20); - Py_CLEAR(clear_module_state->__pyx_codeobj__22); - return 0; -} -#endif -/* #### Code section: module_state_traverse ### */ -#if CYTHON_USE_MODULE_STATE -static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { - __pyx_mstate *traverse_module_state = __pyx_mstate(m); - if (!traverse_module_state) return 0; - Py_VISIT(traverse_module_state->__pyx_d); - Py_VISIT(traverse_module_state->__pyx_b); - Py_VISIT(traverse_module_state->__pyx_cython_runtime); - Py_VISIT(traverse_module_state->__pyx_empty_tuple); - Py_VISIT(traverse_module_state->__pyx_empty_bytes); - Py_VISIT(traverse_module_state->__pyx_empty_unicode); - #ifdef __Pyx_CyFunction_USED - Py_VISIT(traverse_module_state->__pyx_CyFunctionType); - #endif - #ifdef __Pyx_FusedFunction_USED - Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); - #endif - Py_VISIT(traverse_module_state->__pyx_array_type); - Py_VISIT(traverse_module_state->__pyx_type___pyx_array); - Py_VISIT(traverse_module_state->__pyx_MemviewEnum_type); - Py_VISIT(traverse_module_state->__pyx_type___pyx_MemviewEnum); - Py_VISIT(traverse_module_state->__pyx_memoryview_type); - Py_VISIT(traverse_module_state->__pyx_type___pyx_memoryview); - Py_VISIT(traverse_module_state->__pyx_memoryviewslice_type); - Py_VISIT(traverse_module_state->__pyx_type___pyx_memoryviewslice); - Py_VISIT(traverse_module_state->__pyx_kp_u_); - Py_VISIT(traverse_module_state->__pyx_n_s_ASCII); - Py_VISIT(traverse_module_state->__pyx_kp_s_All_dimensions_preceding_dimensi); - Py_VISIT(traverse_module_state->__pyx_n_s_AssertionError); - Py_VISIT(traverse_module_state->__pyx_kp_s_Buffer_view_does_not_expose_stri); - Py_VISIT(traverse_module_state->__pyx_kp_s_Can_only_create_a_buffer_that_is); - Py_VISIT(traverse_module_state->__pyx_kp_s_Cannot_assign_to_read_only_memor); - Py_VISIT(traverse_module_state->__pyx_kp_s_Cannot_create_writable_memory_vi); - Py_VISIT(traverse_module_state->__pyx_kp_u_Cannot_index_with_type); - Py_VISIT(traverse_module_state->__pyx_kp_s_Cannot_transpose_memoryview_with); - Py_VISIT(traverse_module_state->__pyx_kp_s_Dimension_d_is_not_direct); - Py_VISIT(traverse_module_state->__pyx_n_s_Ellipsis); - Py_VISIT(traverse_module_state->__pyx_kp_s_Empty_shape_tuple_for_cython_arr); - Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); - Py_VISIT(traverse_module_state->__pyx_n_s_IndexError); - Py_VISIT(traverse_module_state->__pyx_kp_s_Index_out_of_bounds_axis_d); - Py_VISIT(traverse_module_state->__pyx_kp_s_Indirect_dimensions_not_supporte); - Py_VISIT(traverse_module_state->__pyx_kp_u_Invalid_mode_expected_c_or_fortr); - Py_VISIT(traverse_module_state->__pyx_kp_u_Invalid_shape_in_axis); - Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError); - Py_VISIT(traverse_module_state->__pyx_kp_s_MemoryView_of_r_at_0x_x); - Py_VISIT(traverse_module_state->__pyx_kp_s_MemoryView_of_r_object); - Py_VISIT(traverse_module_state->__pyx_n_b_O); - Py_VISIT(traverse_module_state->__pyx_kp_u_Out_of_bounds_on_buffer_access_a); - Py_VISIT(traverse_module_state->__pyx_n_s_PickleError); - Py_VISIT(traverse_module_state->__pyx_n_s_Sequence); - Py_VISIT(traverse_module_state->__pyx_kp_s_Step_may_not_be_zero_axis_d); - Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); - Py_VISIT(traverse_module_state->__pyx_kp_s_Unable_to_convert_item_to_object); - Py_VISIT(traverse_module_state->__pyx_n_s_ValueError); - Py_VISIT(traverse_module_state->__pyx_n_s_View_MemoryView); - Py_VISIT(traverse_module_state->__pyx_kp_u__2); - Py_VISIT(traverse_module_state->__pyx_n_s__23); - Py_VISIT(traverse_module_state->__pyx_n_s__3); - Py_VISIT(traverse_module_state->__pyx_kp_u__6); - Py_VISIT(traverse_module_state->__pyx_kp_u__7); - Py_VISIT(traverse_module_state->__pyx_n_s_abc); - Py_VISIT(traverse_module_state->__pyx_n_s_allocate_buffer); - Py_VISIT(traverse_module_state->__pyx_kp_u_and); - Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); - Py_VISIT(traverse_module_state->__pyx_n_s_base); - Py_VISIT(traverse_module_state->__pyx_n_s_c); - Py_VISIT(traverse_module_state->__pyx_n_u_c); - Py_VISIT(traverse_module_state->__pyx_n_s_class); - Py_VISIT(traverse_module_state->__pyx_n_s_class_getitem); - Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); - Py_VISIT(traverse_module_state->__pyx_n_s_collections); - Py_VISIT(traverse_module_state->__pyx_kp_s_collections_abc); - Py_VISIT(traverse_module_state->__pyx_kp_s_contiguous_and_direct); - Py_VISIT(traverse_module_state->__pyx_kp_s_contiguous_and_indirect); - Py_VISIT(traverse_module_state->__pyx_kp_s_core_pyx); - Py_VISIT(traverse_module_state->__pyx_n_s_count); - Py_VISIT(traverse_module_state->__pyx_n_s_dict); - Py_VISIT(traverse_module_state->__pyx_kp_u_disable); - Py_VISIT(traverse_module_state->__pyx_n_s_dtype_is_object); - Py_VISIT(traverse_module_state->__pyx_kp_u_enable); - Py_VISIT(traverse_module_state->__pyx_n_s_encode); - Py_VISIT(traverse_module_state->__pyx_n_s_enumerate); - Py_VISIT(traverse_module_state->__pyx_n_s_error); - Py_VISIT(traverse_module_state->__pyx_n_s_flags); - Py_VISIT(traverse_module_state->__pyx_n_s_format); - Py_VISIT(traverse_module_state->__pyx_n_s_fortran); - Py_VISIT(traverse_module_state->__pyx_n_u_fortran); - Py_VISIT(traverse_module_state->__pyx_kp_u_gc); - Py_VISIT(traverse_module_state->__pyx_n_s_getstate); - Py_VISIT(traverse_module_state->__pyx_kp_u_got); - Py_VISIT(traverse_module_state->__pyx_kp_u_got_differing_extents_in_dimensi); - Py_VISIT(traverse_module_state->__pyx_n_s_id); - Py_VISIT(traverse_module_state->__pyx_n_s_import); - Py_VISIT(traverse_module_state->__pyx_n_s_index); - Py_VISIT(traverse_module_state->__pyx_n_s_initializing); - Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); - Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); - Py_VISIT(traverse_module_state->__pyx_n_s_itemsize); - Py_VISIT(traverse_module_state->__pyx_kp_s_itemsize_0_for_cython_array); - Py_VISIT(traverse_module_state->__pyx_n_s_main); - Py_VISIT(traverse_module_state->__pyx_n_s_maximum_path_c); - Py_VISIT(traverse_module_state->__pyx_n_s_memview); - Py_VISIT(traverse_module_state->__pyx_n_s_mode); - Py_VISIT(traverse_module_state->__pyx_n_s_monotonic_align_core); - Py_VISIT(traverse_module_state->__pyx_n_s_name); - Py_VISIT(traverse_module_state->__pyx_n_s_name_2); - Py_VISIT(traverse_module_state->__pyx_n_s_ndim); - Py_VISIT(traverse_module_state->__pyx_n_s_new); - Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non); - Py_VISIT(traverse_module_state->__pyx_n_s_obj); - Py_VISIT(traverse_module_state->__pyx_n_s_pack); - Py_VISIT(traverse_module_state->__pyx_n_s_paths); - Py_VISIT(traverse_module_state->__pyx_n_s_pickle); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_PickleError); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_checksum); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_result); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_type); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Enum); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_vtable); - Py_VISIT(traverse_module_state->__pyx_n_s_range); - Py_VISIT(traverse_module_state->__pyx_n_s_reduce); - Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); - Py_VISIT(traverse_module_state->__pyx_n_s_register); - Py_VISIT(traverse_module_state->__pyx_n_s_setstate); - Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_shape); - Py_VISIT(traverse_module_state->__pyx_n_s_size); - Py_VISIT(traverse_module_state->__pyx_n_s_spec); - Py_VISIT(traverse_module_state->__pyx_n_s_start); - Py_VISIT(traverse_module_state->__pyx_n_s_step); - Py_VISIT(traverse_module_state->__pyx_n_s_stop); - Py_VISIT(traverse_module_state->__pyx_kp_s_strided_and_direct); - Py_VISIT(traverse_module_state->__pyx_kp_s_strided_and_direct_or_indirect); - Py_VISIT(traverse_module_state->__pyx_kp_s_strided_and_indirect); - Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); - Py_VISIT(traverse_module_state->__pyx_n_s_struct); - Py_VISIT(traverse_module_state->__pyx_n_s_sys); - Py_VISIT(traverse_module_state->__pyx_n_s_t_xs); - Py_VISIT(traverse_module_state->__pyx_n_s_t_ys); - Py_VISIT(traverse_module_state->__pyx_n_s_test); - Py_VISIT(traverse_module_state->__pyx_kp_s_unable_to_allocate_array_data); - Py_VISIT(traverse_module_state->__pyx_kp_s_unable_to_allocate_shape_and_str); - Py_VISIT(traverse_module_state->__pyx_n_s_unpack); - Py_VISIT(traverse_module_state->__pyx_n_s_update); - Py_VISIT(traverse_module_state->__pyx_n_s_values); - Py_VISIT(traverse_module_state->__pyx_n_s_version_info); - Py_VISIT(traverse_module_state->__pyx_int_0); - Py_VISIT(traverse_module_state->__pyx_int_1); - Py_VISIT(traverse_module_state->__pyx_int_3); - Py_VISIT(traverse_module_state->__pyx_int_112105877); - Py_VISIT(traverse_module_state->__pyx_int_136983863); - Py_VISIT(traverse_module_state->__pyx_int_184977713); - Py_VISIT(traverse_module_state->__pyx_int_neg_1); - Py_VISIT(traverse_module_state->__pyx_slice__5); - Py_VISIT(traverse_module_state->__pyx_tuple__4); - Py_VISIT(traverse_module_state->__pyx_tuple__8); - Py_VISIT(traverse_module_state->__pyx_tuple__10); - Py_VISIT(traverse_module_state->__pyx_tuple__11); - Py_VISIT(traverse_module_state->__pyx_tuple__12); - Py_VISIT(traverse_module_state->__pyx_tuple__13); - Py_VISIT(traverse_module_state->__pyx_tuple__14); - Py_VISIT(traverse_module_state->__pyx_tuple__15); - Py_VISIT(traverse_module_state->__pyx_tuple__16); - Py_VISIT(traverse_module_state->__pyx_tuple__17); - Py_VISIT(traverse_module_state->__pyx_tuple__18); - Py_VISIT(traverse_module_state->__pyx_tuple__19); - Py_VISIT(traverse_module_state->__pyx_tuple__21); - Py_VISIT(traverse_module_state->__pyx_codeobj__20); - Py_VISIT(traverse_module_state->__pyx_codeobj__22); - return 0; -} -#endif -/* #### Code section: module_state_defines ### */ -#define __pyx_d __pyx_mstate_global->__pyx_d -#define __pyx_b __pyx_mstate_global->__pyx_b -#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime -#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple -#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes -#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode -#ifdef __Pyx_CyFunction_USED -#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType -#endif -#ifdef __Pyx_FusedFunction_USED -#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType -#endif -#ifdef __Pyx_Generator_USED -#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType -#endif -#ifdef __Pyx_IterableCoroutine_USED -#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType -#endif -#ifdef __Pyx_Coroutine_USED -#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType -#endif -#ifdef __Pyx_Coroutine_USED -#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#define __pyx_type___pyx_array __pyx_mstate_global->__pyx_type___pyx_array -#define __pyx_type___pyx_MemviewEnum __pyx_mstate_global->__pyx_type___pyx_MemviewEnum -#define __pyx_type___pyx_memoryview __pyx_mstate_global->__pyx_type___pyx_memoryview -#define __pyx_type___pyx_memoryviewslice __pyx_mstate_global->__pyx_type___pyx_memoryviewslice -#endif -#define __pyx_array_type __pyx_mstate_global->__pyx_array_type -#define __pyx_MemviewEnum_type __pyx_mstate_global->__pyx_MemviewEnum_type -#define __pyx_memoryview_type __pyx_mstate_global->__pyx_memoryview_type -#define __pyx_memoryviewslice_type __pyx_mstate_global->__pyx_memoryviewslice_type -#define __pyx_kp_u_ __pyx_mstate_global->__pyx_kp_u_ -#define __pyx_n_s_ASCII __pyx_mstate_global->__pyx_n_s_ASCII -#define __pyx_kp_s_All_dimensions_preceding_dimensi __pyx_mstate_global->__pyx_kp_s_All_dimensions_preceding_dimensi -#define __pyx_n_s_AssertionError __pyx_mstate_global->__pyx_n_s_AssertionError -#define __pyx_kp_s_Buffer_view_does_not_expose_stri __pyx_mstate_global->__pyx_kp_s_Buffer_view_does_not_expose_stri -#define __pyx_kp_s_Can_only_create_a_buffer_that_is __pyx_mstate_global->__pyx_kp_s_Can_only_create_a_buffer_that_is -#define __pyx_kp_s_Cannot_assign_to_read_only_memor __pyx_mstate_global->__pyx_kp_s_Cannot_assign_to_read_only_memor -#define __pyx_kp_s_Cannot_create_writable_memory_vi __pyx_mstate_global->__pyx_kp_s_Cannot_create_writable_memory_vi -#define __pyx_kp_u_Cannot_index_with_type __pyx_mstate_global->__pyx_kp_u_Cannot_index_with_type -#define __pyx_kp_s_Cannot_transpose_memoryview_with __pyx_mstate_global->__pyx_kp_s_Cannot_transpose_memoryview_with -#define __pyx_kp_s_Dimension_d_is_not_direct __pyx_mstate_global->__pyx_kp_s_Dimension_d_is_not_direct -#define __pyx_n_s_Ellipsis __pyx_mstate_global->__pyx_n_s_Ellipsis -#define __pyx_kp_s_Empty_shape_tuple_for_cython_arr __pyx_mstate_global->__pyx_kp_s_Empty_shape_tuple_for_cython_arr -#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0 -#define __pyx_n_s_IndexError __pyx_mstate_global->__pyx_n_s_IndexError -#define __pyx_kp_s_Index_out_of_bounds_axis_d __pyx_mstate_global->__pyx_kp_s_Index_out_of_bounds_axis_d -#define __pyx_kp_s_Indirect_dimensions_not_supporte __pyx_mstate_global->__pyx_kp_s_Indirect_dimensions_not_supporte -#define __pyx_kp_u_Invalid_mode_expected_c_or_fortr __pyx_mstate_global->__pyx_kp_u_Invalid_mode_expected_c_or_fortr -#define __pyx_kp_u_Invalid_shape_in_axis __pyx_mstate_global->__pyx_kp_u_Invalid_shape_in_axis -#define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError -#define __pyx_kp_s_MemoryView_of_r_at_0x_x __pyx_mstate_global->__pyx_kp_s_MemoryView_of_r_at_0x_x -#define __pyx_kp_s_MemoryView_of_r_object __pyx_mstate_global->__pyx_kp_s_MemoryView_of_r_object -#define __pyx_n_b_O __pyx_mstate_global->__pyx_n_b_O -#define __pyx_kp_u_Out_of_bounds_on_buffer_access_a __pyx_mstate_global->__pyx_kp_u_Out_of_bounds_on_buffer_access_a -#define __pyx_n_s_PickleError __pyx_mstate_global->__pyx_n_s_PickleError -#define __pyx_n_s_Sequence __pyx_mstate_global->__pyx_n_s_Sequence -#define __pyx_kp_s_Step_may_not_be_zero_axis_d __pyx_mstate_global->__pyx_kp_s_Step_may_not_be_zero_axis_d -#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError -#define __pyx_kp_s_Unable_to_convert_item_to_object __pyx_mstate_global->__pyx_kp_s_Unable_to_convert_item_to_object -#define __pyx_n_s_ValueError __pyx_mstate_global->__pyx_n_s_ValueError -#define __pyx_n_s_View_MemoryView __pyx_mstate_global->__pyx_n_s_View_MemoryView -#define __pyx_kp_u__2 __pyx_mstate_global->__pyx_kp_u__2 -#define __pyx_n_s__23 __pyx_mstate_global->__pyx_n_s__23 -#define __pyx_n_s__3 __pyx_mstate_global->__pyx_n_s__3 -#define __pyx_kp_u__6 __pyx_mstate_global->__pyx_kp_u__6 -#define __pyx_kp_u__7 __pyx_mstate_global->__pyx_kp_u__7 -#define __pyx_n_s_abc __pyx_mstate_global->__pyx_n_s_abc -#define __pyx_n_s_allocate_buffer __pyx_mstate_global->__pyx_n_s_allocate_buffer -#define __pyx_kp_u_and __pyx_mstate_global->__pyx_kp_u_and -#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines -#define __pyx_n_s_base __pyx_mstate_global->__pyx_n_s_base -#define __pyx_n_s_c __pyx_mstate_global->__pyx_n_s_c -#define __pyx_n_u_c __pyx_mstate_global->__pyx_n_u_c -#define __pyx_n_s_class __pyx_mstate_global->__pyx_n_s_class -#define __pyx_n_s_class_getitem __pyx_mstate_global->__pyx_n_s_class_getitem -#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback -#define __pyx_n_s_collections __pyx_mstate_global->__pyx_n_s_collections -#define __pyx_kp_s_collections_abc __pyx_mstate_global->__pyx_kp_s_collections_abc -#define __pyx_kp_s_contiguous_and_direct __pyx_mstate_global->__pyx_kp_s_contiguous_and_direct -#define __pyx_kp_s_contiguous_and_indirect __pyx_mstate_global->__pyx_kp_s_contiguous_and_indirect -#define __pyx_kp_s_core_pyx __pyx_mstate_global->__pyx_kp_s_core_pyx -#define __pyx_n_s_count __pyx_mstate_global->__pyx_n_s_count -#define __pyx_n_s_dict __pyx_mstate_global->__pyx_n_s_dict -#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable -#define __pyx_n_s_dtype_is_object __pyx_mstate_global->__pyx_n_s_dtype_is_object -#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable -#define __pyx_n_s_encode __pyx_mstate_global->__pyx_n_s_encode -#define __pyx_n_s_enumerate __pyx_mstate_global->__pyx_n_s_enumerate -#define __pyx_n_s_error __pyx_mstate_global->__pyx_n_s_error -#define __pyx_n_s_flags __pyx_mstate_global->__pyx_n_s_flags -#define __pyx_n_s_format __pyx_mstate_global->__pyx_n_s_format -#define __pyx_n_s_fortran __pyx_mstate_global->__pyx_n_s_fortran -#define __pyx_n_u_fortran __pyx_mstate_global->__pyx_n_u_fortran -#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc -#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate -#define __pyx_kp_u_got __pyx_mstate_global->__pyx_kp_u_got -#define __pyx_kp_u_got_differing_extents_in_dimensi __pyx_mstate_global->__pyx_kp_u_got_differing_extents_in_dimensi -#define __pyx_n_s_id __pyx_mstate_global->__pyx_n_s_id -#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import -#define __pyx_n_s_index __pyx_mstate_global->__pyx_n_s_index -#define __pyx_n_s_initializing __pyx_mstate_global->__pyx_n_s_initializing -#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine -#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled -#define __pyx_n_s_itemsize __pyx_mstate_global->__pyx_n_s_itemsize -#define __pyx_kp_s_itemsize_0_for_cython_array __pyx_mstate_global->__pyx_kp_s_itemsize_0_for_cython_array -#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main -#define __pyx_n_s_maximum_path_c __pyx_mstate_global->__pyx_n_s_maximum_path_c -#define __pyx_n_s_memview __pyx_mstate_global->__pyx_n_s_memview -#define __pyx_n_s_mode __pyx_mstate_global->__pyx_n_s_mode -#define __pyx_n_s_monotonic_align_core __pyx_mstate_global->__pyx_n_s_monotonic_align_core -#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name -#define __pyx_n_s_name_2 __pyx_mstate_global->__pyx_n_s_name_2 -#define __pyx_n_s_ndim __pyx_mstate_global->__pyx_n_s_ndim -#define __pyx_n_s_new __pyx_mstate_global->__pyx_n_s_new -#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non -#define __pyx_n_s_obj __pyx_mstate_global->__pyx_n_s_obj -#define __pyx_n_s_pack __pyx_mstate_global->__pyx_n_s_pack -#define __pyx_n_s_paths __pyx_mstate_global->__pyx_n_s_paths -#define __pyx_n_s_pickle __pyx_mstate_global->__pyx_n_s_pickle -#define __pyx_n_s_pyx_PickleError __pyx_mstate_global->__pyx_n_s_pyx_PickleError -#define __pyx_n_s_pyx_checksum __pyx_mstate_global->__pyx_n_s_pyx_checksum -#define __pyx_n_s_pyx_result __pyx_mstate_global->__pyx_n_s_pyx_result -#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state -#define __pyx_n_s_pyx_type __pyx_mstate_global->__pyx_n_s_pyx_type -#define __pyx_n_s_pyx_unpickle_Enum __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Enum -#define __pyx_n_s_pyx_vtable __pyx_mstate_global->__pyx_n_s_pyx_vtable -#define __pyx_n_s_range __pyx_mstate_global->__pyx_n_s_range -#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce -#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython -#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex -#define __pyx_n_s_register __pyx_mstate_global->__pyx_n_s_register -#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate -#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython -#define __pyx_n_s_shape __pyx_mstate_global->__pyx_n_s_shape -#define __pyx_n_s_size __pyx_mstate_global->__pyx_n_s_size -#define __pyx_n_s_spec __pyx_mstate_global->__pyx_n_s_spec -#define __pyx_n_s_start __pyx_mstate_global->__pyx_n_s_start -#define __pyx_n_s_step __pyx_mstate_global->__pyx_n_s_step -#define __pyx_n_s_stop __pyx_mstate_global->__pyx_n_s_stop -#define __pyx_kp_s_strided_and_direct __pyx_mstate_global->__pyx_kp_s_strided_and_direct -#define __pyx_kp_s_strided_and_direct_or_indirect __pyx_mstate_global->__pyx_kp_s_strided_and_direct_or_indirect -#define __pyx_kp_s_strided_and_indirect __pyx_mstate_global->__pyx_kp_s_strided_and_indirect -#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource -#define __pyx_n_s_struct __pyx_mstate_global->__pyx_n_s_struct -#define __pyx_n_s_sys __pyx_mstate_global->__pyx_n_s_sys -#define __pyx_n_s_t_xs __pyx_mstate_global->__pyx_n_s_t_xs -#define __pyx_n_s_t_ys __pyx_mstate_global->__pyx_n_s_t_ys -#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test -#define __pyx_kp_s_unable_to_allocate_array_data __pyx_mstate_global->__pyx_kp_s_unable_to_allocate_array_data -#define __pyx_kp_s_unable_to_allocate_shape_and_str __pyx_mstate_global->__pyx_kp_s_unable_to_allocate_shape_and_str -#define __pyx_n_s_unpack __pyx_mstate_global->__pyx_n_s_unpack -#define __pyx_n_s_update __pyx_mstate_global->__pyx_n_s_update -#define __pyx_n_s_values __pyx_mstate_global->__pyx_n_s_values -#define __pyx_n_s_version_info __pyx_mstate_global->__pyx_n_s_version_info -#define __pyx_int_0 __pyx_mstate_global->__pyx_int_0 -#define __pyx_int_1 __pyx_mstate_global->__pyx_int_1 -#define __pyx_int_3 __pyx_mstate_global->__pyx_int_3 -#define __pyx_int_112105877 __pyx_mstate_global->__pyx_int_112105877 -#define __pyx_int_136983863 __pyx_mstate_global->__pyx_int_136983863 -#define __pyx_int_184977713 __pyx_mstate_global->__pyx_int_184977713 -#define __pyx_int_neg_1 __pyx_mstate_global->__pyx_int_neg_1 -#define __pyx_k__9 __pyx_mstate_global->__pyx_k__9 -#define __pyx_slice__5 __pyx_mstate_global->__pyx_slice__5 -#define __pyx_tuple__4 __pyx_mstate_global->__pyx_tuple__4 -#define __pyx_tuple__8 __pyx_mstate_global->__pyx_tuple__8 -#define __pyx_tuple__10 __pyx_mstate_global->__pyx_tuple__10 -#define __pyx_tuple__11 __pyx_mstate_global->__pyx_tuple__11 -#define __pyx_tuple__12 __pyx_mstate_global->__pyx_tuple__12 -#define __pyx_tuple__13 __pyx_mstate_global->__pyx_tuple__13 -#define __pyx_tuple__14 __pyx_mstate_global->__pyx_tuple__14 -#define __pyx_tuple__15 __pyx_mstate_global->__pyx_tuple__15 -#define __pyx_tuple__16 __pyx_mstate_global->__pyx_tuple__16 -#define __pyx_tuple__17 __pyx_mstate_global->__pyx_tuple__17 -#define __pyx_tuple__18 __pyx_mstate_global->__pyx_tuple__18 -#define __pyx_tuple__19 __pyx_mstate_global->__pyx_tuple__19 -#define __pyx_tuple__21 __pyx_mstate_global->__pyx_tuple__21 -#define __pyx_codeobj__20 __pyx_mstate_global->__pyx_codeobj__20 -#define __pyx_codeobj__22 __pyx_mstate_global->__pyx_codeobj__22 -/* #### Code section: module_code ### */ - -/* "View.MemoryView":131 - * cdef bint dtype_is_object - * - * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< - * mode="c", bint allocate_buffer=True): - * - */ - -/* Python wrapper */ -static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_shape = 0; - Py_ssize_t __pyx_v_itemsize; - PyObject *__pyx_v_format = 0; - PyObject *__pyx_v_mode = 0; - int __pyx_v_allocate_buffer; - CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_shape,&__pyx_n_s_itemsize,&__pyx_n_s_format,&__pyx_n_s_mode,&__pyx_n_s_allocate_buffer,0}; - PyObject* values[5] = {0,0,0,0,0}; - values[3] = ((PyObject *)__pyx_n_s_c); - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_VARARGS(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_VARARGS(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_shape)) != 0)) kw_args--; - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_itemsize)) != 0)) kw_args--; - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 1); __PYX_ERR(1, 131, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_format)) != 0)) kw_args--; - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 2); __PYX_ERR(1, 131, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_mode); - if (value) { values[3] = value; kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_allocate_buffer); - if (value) { values[4] = value; kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(1, 131, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_VARARGS(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_VARARGS(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); - values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); - values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_shape = ((PyObject*)values[0]); - __pyx_v_itemsize = __Pyx_PyIndex_AsSsize_t(values[1]); if (unlikely((__pyx_v_itemsize == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) - __pyx_v_format = values[2]; - __pyx_v_mode = values[3]; - if (values[4]) { - __pyx_v_allocate_buffer = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_allocate_buffer == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 132, __pyx_L3_error) - } else { - - /* "View.MemoryView":132 - * - * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, - * mode="c", bint allocate_buffer=True): # <<<<<<<<<<<<<< - * - * cdef int idx - */ - __pyx_v_allocate_buffer = ((int)1); - } - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, __pyx_nargs); __PYX_ERR(1, 131, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return -1; - __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_shape), (&PyTuple_Type), 1, "shape", 1))) __PYX_ERR(1, 131, __pyx_L1_error) - if (unlikely(((PyObject *)__pyx_v_format) == Py_None)) { - PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "format"); __PYX_ERR(1, 131, __pyx_L1_error) - } - __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v_shape, __pyx_v_itemsize, __pyx_v_format, __pyx_v_mode, __pyx_v_allocate_buffer); - - /* "View.MemoryView":131 - * cdef bint dtype_is_object - * - * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< - * mode="c", bint allocate_buffer=True): - * - */ - - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer) { - int __pyx_v_idx; - Py_ssize_t __pyx_v_dim; - char __pyx_v_order; - int __pyx_r; - __Pyx_RefNannyDeclarations - Py_ssize_t __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - int __pyx_t_7; - char *__pyx_t_8; - Py_ssize_t __pyx_t_9; - Py_UCS4 __pyx_t_10; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__cinit__", 0); - __Pyx_INCREF(__pyx_v_format); - - /* "View.MemoryView":137 - * cdef Py_ssize_t dim - * - * self.ndim = len(shape) # <<<<<<<<<<<<<< - * self.itemsize = itemsize - * - */ - if (unlikely(__pyx_v_shape == Py_None)) { - PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(1, 137, __pyx_L1_error) - } - __pyx_t_1 = PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 137, __pyx_L1_error) - __pyx_v_self->ndim = ((int)__pyx_t_1); - - /* "View.MemoryView":138 - * - * self.ndim = len(shape) - * self.itemsize = itemsize # <<<<<<<<<<<<<< - * - * if not self.ndim: - */ - __pyx_v_self->itemsize = __pyx_v_itemsize; - - /* "View.MemoryView":140 - * self.itemsize = itemsize - * - * if not self.ndim: # <<<<<<<<<<<<<< - * raise ValueError, "Empty shape tuple for cython.array" - * - */ - __pyx_t_2 = (!(__pyx_v_self->ndim != 0)); - if (unlikely(__pyx_t_2)) { - - /* "View.MemoryView":141 - * - * if not self.ndim: - * raise ValueError, "Empty shape tuple for cython.array" # <<<<<<<<<<<<<< - * - * if itemsize <= 0: - */ - __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Empty_shape_tuple_for_cython_arr, 0, 0); - __PYX_ERR(1, 141, __pyx_L1_error) - - /* "View.MemoryView":140 - * self.itemsize = itemsize - * - * if not self.ndim: # <<<<<<<<<<<<<< - * raise ValueError, "Empty shape tuple for cython.array" - * - */ - } - - /* "View.MemoryView":143 - * raise ValueError, "Empty shape tuple for cython.array" - * - * if itemsize <= 0: # <<<<<<<<<<<<<< - * raise ValueError, "itemsize <= 0 for cython.array" - * - */ - __pyx_t_2 = (__pyx_v_itemsize <= 0); - if (unlikely(__pyx_t_2)) { - - /* "View.MemoryView":144 - * - * if itemsize <= 0: - * raise ValueError, "itemsize <= 0 for cython.array" # <<<<<<<<<<<<<< - * - * if not isinstance(format, bytes): - */ - __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_itemsize_0_for_cython_array, 0, 0); - __PYX_ERR(1, 144, __pyx_L1_error) - - /* "View.MemoryView":143 - * raise ValueError, "Empty shape tuple for cython.array" - * - * if itemsize <= 0: # <<<<<<<<<<<<<< - * raise ValueError, "itemsize <= 0 for cython.array" - * - */ - } - - /* "View.MemoryView":146 - * raise ValueError, "itemsize <= 0 for cython.array" - * - * if not isinstance(format, bytes): # <<<<<<<<<<<<<< - * format = format.encode('ASCII') - * self._format = format # keep a reference to the byte string - */ - __pyx_t_2 = PyBytes_Check(__pyx_v_format); - __pyx_t_3 = (!__pyx_t_2); - if (__pyx_t_3) { - - /* "View.MemoryView":147 - * - * if not isinstance(format, bytes): - * format = format.encode('ASCII') # <<<<<<<<<<<<<< - * self._format = format # keep a reference to the byte string - * self.format = self._format - */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = NULL; - __pyx_t_7 = 0; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_7 = 1; - } - } - { - PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_n_s_ASCII}; - __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } - __Pyx_DECREF_SET(__pyx_v_format, __pyx_t_4); - __pyx_t_4 = 0; - - /* "View.MemoryView":146 - * raise ValueError, "itemsize <= 0 for cython.array" - * - * if not isinstance(format, bytes): # <<<<<<<<<<<<<< - * format = format.encode('ASCII') - * self._format = format # keep a reference to the byte string - */ - } - - /* "View.MemoryView":148 - * if not isinstance(format, bytes): - * format = format.encode('ASCII') - * self._format = format # keep a reference to the byte string # <<<<<<<<<<<<<< - * self.format = self._format - * - */ - if (!(likely(PyBytes_CheckExact(__pyx_v_format))||((__pyx_v_format) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_v_format))) __PYX_ERR(1, 148, __pyx_L1_error) - __pyx_t_4 = __pyx_v_format; - __Pyx_INCREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_4); - __Pyx_GOTREF(__pyx_v_self->_format); - __Pyx_DECREF(__pyx_v_self->_format); - __pyx_v_self->_format = ((PyObject*)__pyx_t_4); - __pyx_t_4 = 0; - - /* "View.MemoryView":149 - * format = format.encode('ASCII') - * self._format = format # keep a reference to the byte string - * self.format = self._format # <<<<<<<<<<<<<< - * - * - */ - if (unlikely(__pyx_v_self->_format == Py_None)) { - PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); - __PYX_ERR(1, 149, __pyx_L1_error) - } - __pyx_t_8 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_8) && PyErr_Occurred())) __PYX_ERR(1, 149, __pyx_L1_error) - __pyx_v_self->format = __pyx_t_8; - - /* "View.MemoryView":152 - * - * - * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) # <<<<<<<<<<<<<< - * self._strides = self._shape + self.ndim - * - */ - __pyx_v_self->_shape = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * __pyx_v_self->ndim) * 2))); - - /* "View.MemoryView":153 - * - * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) - * self._strides = self._shape + self.ndim # <<<<<<<<<<<<<< - * - * if not self._shape: - */ - __pyx_v_self->_strides = (__pyx_v_self->_shape + __pyx_v_self->ndim); - - /* "View.MemoryView":155 - * self._strides = self._shape + self.ndim - * - * if not self._shape: # <<<<<<<<<<<<<< - * raise MemoryError, "unable to allocate shape and strides." - * - */ - __pyx_t_3 = (!(__pyx_v_self->_shape != 0)); - if (unlikely(__pyx_t_3)) { - - /* "View.MemoryView":156 - * - * if not self._shape: - * raise MemoryError, "unable to allocate shape and strides." # <<<<<<<<<<<<<< - * - * - */ - __Pyx_Raise(__pyx_builtin_MemoryError, __pyx_kp_s_unable_to_allocate_shape_and_str, 0, 0); - __PYX_ERR(1, 156, __pyx_L1_error) - - /* "View.MemoryView":155 - * self._strides = self._shape + self.ndim - * - * if not self._shape: # <<<<<<<<<<<<<< - * raise MemoryError, "unable to allocate shape and strides." - * - */ - } - - /* "View.MemoryView":159 - * - * - * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< - * if dim <= 0: - * raise ValueError, f"Invalid shape in axis {idx}: {dim}." - */ - __pyx_t_7 = 0; - __pyx_t_4 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_4); __pyx_t_1 = 0; - for (;;) { - if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_4)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(1, 159, __pyx_L1_error) - #else - __pyx_t_5 = PySequence_ITEM(__pyx_t_4, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 159, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - #endif - __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 159, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_dim = __pyx_t_9; - __pyx_v_idx = __pyx_t_7; - __pyx_t_7 = (__pyx_t_7 + 1); - - /* "View.MemoryView":160 - * - * for idx, dim in enumerate(shape): - * if dim <= 0: # <<<<<<<<<<<<<< - * raise ValueError, f"Invalid shape in axis {idx}: {dim}." - * self._shape[idx] = dim - */ - __pyx_t_3 = (__pyx_v_dim <= 0); - if (unlikely(__pyx_t_3)) { - - /* "View.MemoryView":161 - * for idx, dim in enumerate(shape): - * if dim <= 0: - * raise ValueError, f"Invalid shape in axis {idx}: {dim}." # <<<<<<<<<<<<<< - * self._shape[idx] = dim - * - */ - __pyx_t_5 = PyTuple_New(5); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_9 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_Invalid_shape_in_axis); - __pyx_t_9 += 22; - __Pyx_GIVEREF(__pyx_kp_u_Invalid_shape_in_axis); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_kp_u_Invalid_shape_in_axis); - __pyx_t_6 = __Pyx_PyUnicode_From_int(__pyx_v_idx, 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_6); - __pyx_t_6 = 0; - __Pyx_INCREF(__pyx_kp_u_); - __pyx_t_9 += 2; - __Pyx_GIVEREF(__pyx_kp_u_); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_kp_u_); - __pyx_t_6 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_6); - __pyx_t_6 = 0; - __Pyx_INCREF(__pyx_kp_u__2); - __pyx_t_9 += 1; - __Pyx_GIVEREF(__pyx_kp_u__2); - PyTuple_SET_ITEM(__pyx_t_5, 4, __pyx_kp_u__2); - __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_5, 5, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_Raise(__pyx_builtin_ValueError, __pyx_t_6, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(1, 161, __pyx_L1_error) - - /* "View.MemoryView":160 - * - * for idx, dim in enumerate(shape): - * if dim <= 0: # <<<<<<<<<<<<<< - * raise ValueError, f"Invalid shape in axis {idx}: {dim}." - * self._shape[idx] = dim - */ - } - - /* "View.MemoryView":162 - * if dim <= 0: - * raise ValueError, f"Invalid shape in axis {idx}: {dim}." - * self._shape[idx] = dim # <<<<<<<<<<<<<< - * - * cdef char order - */ - (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim; - - /* "View.MemoryView":159 - * - * - * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< - * if dim <= 0: - * raise ValueError, f"Invalid shape in axis {idx}: {dim}." - */ - } - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - - /* "View.MemoryView":165 - * - * cdef char order - * if mode == 'c': # <<<<<<<<<<<<<< - * order = b'C' - * self.mode = u'c' - */ - __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_c, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 165, __pyx_L1_error) - if (__pyx_t_3) { - - /* "View.MemoryView":166 - * cdef char order - * if mode == 'c': - * order = b'C' # <<<<<<<<<<<<<< - * self.mode = u'c' - * elif mode == 'fortran': - */ - __pyx_v_order = 'C'; - - /* "View.MemoryView":167 - * if mode == 'c': - * order = b'C' - * self.mode = u'c' # <<<<<<<<<<<<<< - * elif mode == 'fortran': - * order = b'F' - */ - __Pyx_INCREF(__pyx_n_u_c); - __Pyx_GIVEREF(__pyx_n_u_c); - __Pyx_GOTREF(__pyx_v_self->mode); - __Pyx_DECREF(__pyx_v_self->mode); - __pyx_v_self->mode = __pyx_n_u_c; - - /* "View.MemoryView":165 - * - * cdef char order - * if mode == 'c': # <<<<<<<<<<<<<< - * order = b'C' - * self.mode = u'c' - */ - goto __pyx_L11; - } - - /* "View.MemoryView":168 - * order = b'C' - * self.mode = u'c' - * elif mode == 'fortran': # <<<<<<<<<<<<<< - * order = b'F' - * self.mode = u'fortran' - */ - __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_fortran, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 168, __pyx_L1_error) - if (likely(__pyx_t_3)) { - - /* "View.MemoryView":169 - * self.mode = u'c' - * elif mode == 'fortran': - * order = b'F' # <<<<<<<<<<<<<< - * self.mode = u'fortran' - * else: - */ - __pyx_v_order = 'F'; - - /* "View.MemoryView":170 - * elif mode == 'fortran': - * order = b'F' - * self.mode = u'fortran' # <<<<<<<<<<<<<< - * else: - * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" - */ - __Pyx_INCREF(__pyx_n_u_fortran); - __Pyx_GIVEREF(__pyx_n_u_fortran); - __Pyx_GOTREF(__pyx_v_self->mode); - __Pyx_DECREF(__pyx_v_self->mode); - __pyx_v_self->mode = __pyx_n_u_fortran; - - /* "View.MemoryView":168 - * order = b'C' - * self.mode = u'c' - * elif mode == 'fortran': # <<<<<<<<<<<<<< - * order = b'F' - * self.mode = u'fortran' - */ - goto __pyx_L11; - } - - /* "View.MemoryView":172 - * self.mode = u'fortran' - * else: - * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" # <<<<<<<<<<<<<< - * - * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) - */ - /*else*/ { - __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_v_mode, __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 172, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Invalid_mode_expected_c_or_fortr, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 172, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_Raise(__pyx_builtin_ValueError, __pyx_t_6, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(1, 172, __pyx_L1_error) - } - __pyx_L11:; - - /* "View.MemoryView":174 - * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" - * - * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) # <<<<<<<<<<<<<< - * - * self.free_data = allocate_buffer - */ - __pyx_v_self->len = __pyx_fill_contig_strides_array(__pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_itemsize, __pyx_v_self->ndim, __pyx_v_order); - - /* "View.MemoryView":176 - * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) - * - * self.free_data = allocate_buffer # <<<<<<<<<<<<<< - * self.dtype_is_object = format == b'O' - * - */ - __pyx_v_self->free_data = __pyx_v_allocate_buffer; - - /* "View.MemoryView":177 - * - * self.free_data = allocate_buffer - * self.dtype_is_object = format == b'O' # <<<<<<<<<<<<<< - * - * if allocate_buffer: - */ - __pyx_t_6 = PyObject_RichCompare(__pyx_v_format, __pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 177, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 177, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_v_self->dtype_is_object = __pyx_t_3; - - /* "View.MemoryView":179 - * self.dtype_is_object = format == b'O' - * - * if allocate_buffer: # <<<<<<<<<<<<<< - * _allocate_buffer(self) - * - */ - if (__pyx_v_allocate_buffer) { - - /* "View.MemoryView":180 - * - * if allocate_buffer: - * _allocate_buffer(self) # <<<<<<<<<<<<<< - * - * @cname('getbuffer') - */ - __pyx_t_7 = __pyx_array_allocate_buffer(__pyx_v_self); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(1, 180, __pyx_L1_error) - - /* "View.MemoryView":179 - * self.dtype_is_object = format == b'O' - * - * if allocate_buffer: # <<<<<<<<<<<<<< - * _allocate_buffer(self) - * - */ - } - - /* "View.MemoryView":131 - * cdef bint dtype_is_object - * - * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< - * mode="c", bint allocate_buffer=True): - * - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_format); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":182 - * _allocate_buffer(self) - * - * @cname('getbuffer') # <<<<<<<<<<<<<< - * def __getbuffer__(self, Py_buffer *info, int flags): - * cdef int bufmode = -1 - */ - -/* Python wrapper */ -CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ -CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); - __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(((struct __pyx_array_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - int __pyx_v_bufmode; - int __pyx_r; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - char *__pyx_t_2; - Py_ssize_t __pyx_t_3; - int __pyx_t_4; - Py_ssize_t *__pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - if (unlikely(__pyx_v_info == NULL)) { - PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); - return -1; - } - __Pyx_RefNannySetupContext("__getbuffer__", 0); - __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(__pyx_v_info->obj); - - /* "View.MemoryView":184 - * @cname('getbuffer') - * def __getbuffer__(self, Py_buffer *info, int flags): - * cdef int bufmode = -1 # <<<<<<<<<<<<<< - * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): - * if self.mode == u"c": - */ - __pyx_v_bufmode = -1; - - /* "View.MemoryView":185 - * def __getbuffer__(self, Py_buffer *info, int flags): - * cdef int bufmode = -1 - * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): # <<<<<<<<<<<<<< - * if self.mode == u"c": - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - */ - __pyx_t_1 = ((__pyx_v_flags & ((PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS) | PyBUF_ANY_CONTIGUOUS)) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":186 - * cdef int bufmode = -1 - * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): - * if self.mode == u"c": # <<<<<<<<<<<<<< - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * elif self.mode == u"fortran": - */ - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_c, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 186, __pyx_L1_error) - if (__pyx_t_1) { - - /* "View.MemoryView":187 - * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): - * if self.mode == u"c": - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< - * elif self.mode == u"fortran": - * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - */ - __pyx_v_bufmode = (PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); - - /* "View.MemoryView":186 - * cdef int bufmode = -1 - * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): - * if self.mode == u"c": # <<<<<<<<<<<<<< - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * elif self.mode == u"fortran": - */ - goto __pyx_L4; - } - - /* "View.MemoryView":188 - * if self.mode == u"c": - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * elif self.mode == u"fortran": # <<<<<<<<<<<<<< - * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * if not (flags & bufmode): - */ - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_fortran, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 188, __pyx_L1_error) - if (__pyx_t_1) { - - /* "View.MemoryView":189 - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * elif self.mode == u"fortran": - * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< - * if not (flags & bufmode): - * raise ValueError, "Can only create a buffer that is contiguous in memory." - */ - __pyx_v_bufmode = (PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); - - /* "View.MemoryView":188 - * if self.mode == u"c": - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * elif self.mode == u"fortran": # <<<<<<<<<<<<<< - * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * if not (flags & bufmode): - */ - } - __pyx_L4:; - - /* "View.MemoryView":190 - * elif self.mode == u"fortran": - * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * if not (flags & bufmode): # <<<<<<<<<<<<<< - * raise ValueError, "Can only create a buffer that is contiguous in memory." - * info.buf = self.data - */ - __pyx_t_1 = (!((__pyx_v_flags & __pyx_v_bufmode) != 0)); - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":191 - * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * if not (flags & bufmode): - * raise ValueError, "Can only create a buffer that is contiguous in memory." # <<<<<<<<<<<<<< - * info.buf = self.data - * info.len = self.len - */ - __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Can_only_create_a_buffer_that_is, 0, 0); - __PYX_ERR(1, 191, __pyx_L1_error) - - /* "View.MemoryView":190 - * elif self.mode == u"fortran": - * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * if not (flags & bufmode): # <<<<<<<<<<<<<< - * raise ValueError, "Can only create a buffer that is contiguous in memory." - * info.buf = self.data - */ - } - - /* "View.MemoryView":185 - * def __getbuffer__(self, Py_buffer *info, int flags): - * cdef int bufmode = -1 - * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): # <<<<<<<<<<<<<< - * if self.mode == u"c": - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - */ - } - - /* "View.MemoryView":192 - * if not (flags & bufmode): - * raise ValueError, "Can only create a buffer that is contiguous in memory." - * info.buf = self.data # <<<<<<<<<<<<<< - * info.len = self.len - * - */ - __pyx_t_2 = __pyx_v_self->data; - __pyx_v_info->buf = __pyx_t_2; - - /* "View.MemoryView":193 - * raise ValueError, "Can only create a buffer that is contiguous in memory." - * info.buf = self.data - * info.len = self.len # <<<<<<<<<<<<<< - * - * if flags & PyBUF_STRIDES: - */ - __pyx_t_3 = __pyx_v_self->len; - __pyx_v_info->len = __pyx_t_3; - - /* "View.MemoryView":195 - * info.len = self.len - * - * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< - * info.ndim = self.ndim - * info.shape = self._shape - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":196 - * - * if flags & PyBUF_STRIDES: - * info.ndim = self.ndim # <<<<<<<<<<<<<< - * info.shape = self._shape - * info.strides = self._strides - */ - __pyx_t_4 = __pyx_v_self->ndim; - __pyx_v_info->ndim = __pyx_t_4; - - /* "View.MemoryView":197 - * if flags & PyBUF_STRIDES: - * info.ndim = self.ndim - * info.shape = self._shape # <<<<<<<<<<<<<< - * info.strides = self._strides - * else: - */ - __pyx_t_5 = __pyx_v_self->_shape; - __pyx_v_info->shape = __pyx_t_5; - - /* "View.MemoryView":198 - * info.ndim = self.ndim - * info.shape = self._shape - * info.strides = self._strides # <<<<<<<<<<<<<< - * else: - * info.ndim = 1 - */ - __pyx_t_5 = __pyx_v_self->_strides; - __pyx_v_info->strides = __pyx_t_5; - - /* "View.MemoryView":195 - * info.len = self.len - * - * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< - * info.ndim = self.ndim - * info.shape = self._shape - */ - goto __pyx_L6; - } - - /* "View.MemoryView":200 - * info.strides = self._strides - * else: - * info.ndim = 1 # <<<<<<<<<<<<<< - * info.shape = &self.len if flags & PyBUF_ND else NULL - * info.strides = NULL - */ - /*else*/ { - __pyx_v_info->ndim = 1; - - /* "View.MemoryView":201 - * else: - * info.ndim = 1 - * info.shape = &self.len if flags & PyBUF_ND else NULL # <<<<<<<<<<<<<< - * info.strides = NULL - * - */ - if (((__pyx_v_flags & PyBUF_ND) != 0)) { - __pyx_t_5 = (&__pyx_v_self->len); - } else { - __pyx_t_5 = NULL; - } - __pyx_v_info->shape = __pyx_t_5; - - /* "View.MemoryView":202 - * info.ndim = 1 - * info.shape = &self.len if flags & PyBUF_ND else NULL - * info.strides = NULL # <<<<<<<<<<<<<< - * - * info.suboffsets = NULL - */ - __pyx_v_info->strides = NULL; - } - __pyx_L6:; - - /* "View.MemoryView":204 - * info.strides = NULL - * - * info.suboffsets = NULL # <<<<<<<<<<<<<< - * info.itemsize = self.itemsize - * info.readonly = 0 - */ - __pyx_v_info->suboffsets = NULL; - - /* "View.MemoryView":205 - * - * info.suboffsets = NULL - * info.itemsize = self.itemsize # <<<<<<<<<<<<<< - * info.readonly = 0 - * info.format = self.format if flags & PyBUF_FORMAT else NULL - */ - __pyx_t_3 = __pyx_v_self->itemsize; - __pyx_v_info->itemsize = __pyx_t_3; - - /* "View.MemoryView":206 - * info.suboffsets = NULL - * info.itemsize = self.itemsize - * info.readonly = 0 # <<<<<<<<<<<<<< - * info.format = self.format if flags & PyBUF_FORMAT else NULL - * info.obj = self - */ - __pyx_v_info->readonly = 0; - - /* "View.MemoryView":207 - * info.itemsize = self.itemsize - * info.readonly = 0 - * info.format = self.format if flags & PyBUF_FORMAT else NULL # <<<<<<<<<<<<<< - * info.obj = self - * - */ - if (((__pyx_v_flags & PyBUF_FORMAT) != 0)) { - __pyx_t_2 = __pyx_v_self->format; - } else { - __pyx_t_2 = NULL; - } - __pyx_v_info->format = __pyx_t_2; - - /* "View.MemoryView":208 - * info.readonly = 0 - * info.format = self.format if flags & PyBUF_FORMAT else NULL - * info.obj = self # <<<<<<<<<<<<<< - * - * def __dealloc__(array self): - */ - __Pyx_INCREF((PyObject *)__pyx_v_self); - __Pyx_GIVEREF((PyObject *)__pyx_v_self); - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); - __pyx_v_info->obj = ((PyObject *)__pyx_v_self); - - /* "View.MemoryView":182 - * _allocate_buffer(self) - * - * @cname('getbuffer') # <<<<<<<<<<<<<< - * def __getbuffer__(self, Py_buffer *info, int flags): - * cdef int bufmode = -1 - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_AddTraceback("View.MemoryView.array.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - if (__pyx_v_info->obj != NULL) { - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; - } - goto __pyx_L2; - __pyx_L0:; - if (__pyx_v_info->obj == Py_None) { - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; - } - __pyx_L2:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":210 - * info.obj = self - * - * def __dealloc__(array self): # <<<<<<<<<<<<<< - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) - */ - -/* Python wrapper */ -static void __pyx_array___dealloc__(PyObject *__pyx_v_self); /*proto*/ -static void __pyx_array___dealloc__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); - __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(((struct __pyx_array_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self) { - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - __Pyx_RefNannySetupContext("__dealloc__", 0); - - /* "View.MemoryView":211 - * - * def __dealloc__(array self): - * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< - * self.callback_free_data(self.data) - * elif self.free_data and self.data is not NULL: - */ - __pyx_t_1 = (__pyx_v_self->callback_free_data != NULL); - if (__pyx_t_1) { - - /* "View.MemoryView":212 - * def __dealloc__(array self): - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) # <<<<<<<<<<<<<< - * elif self.free_data and self.data is not NULL: - * if self.dtype_is_object: - */ - __pyx_v_self->callback_free_data(__pyx_v_self->data); - - /* "View.MemoryView":211 - * - * def __dealloc__(array self): - * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< - * self.callback_free_data(self.data) - * elif self.free_data and self.data is not NULL: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":213 - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) - * elif self.free_data and self.data is not NULL: # <<<<<<<<<<<<<< - * if self.dtype_is_object: - * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) - */ - if (__pyx_v_self->free_data) { - } else { - __pyx_t_1 = __pyx_v_self->free_data; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_2 = (__pyx_v_self->data != NULL); - __pyx_t_1 = __pyx_t_2; - __pyx_L4_bool_binop_done:; - if (__pyx_t_1) { - - /* "View.MemoryView":214 - * self.callback_free_data(self.data) - * elif self.free_data and self.data is not NULL: - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) - * free(self.data) - */ - if (__pyx_v_self->dtype_is_object) { - - /* "View.MemoryView":215 - * elif self.free_data and self.data is not NULL: - * if self.dtype_is_object: - * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) # <<<<<<<<<<<<<< - * free(self.data) - * PyObject_Free(self._shape) - */ - __pyx_memoryview_refcount_objects_in_slice(__pyx_v_self->data, __pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_self->ndim, 0); - - /* "View.MemoryView":214 - * self.callback_free_data(self.data) - * elif self.free_data and self.data is not NULL: - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) - * free(self.data) - */ - } - - /* "View.MemoryView":216 - * if self.dtype_is_object: - * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) - * free(self.data) # <<<<<<<<<<<<<< - * PyObject_Free(self._shape) - * - */ - free(__pyx_v_self->data); - - /* "View.MemoryView":213 - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) - * elif self.free_data and self.data is not NULL: # <<<<<<<<<<<<<< - * if self.dtype_is_object: - * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) - */ - } - __pyx_L3:; - - /* "View.MemoryView":217 - * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) - * free(self.data) - * PyObject_Free(self._shape) # <<<<<<<<<<<<<< - * - * @property - */ - PyObject_Free(__pyx_v_self->_shape); - - /* "View.MemoryView":210 - * info.obj = self - * - * def __dealloc__(array self): # <<<<<<<<<<<<<< - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) - */ - - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -/* "View.MemoryView":219 - * PyObject_Free(self._shape) - * - * @property # <<<<<<<<<<<<<< - * def memview(self): - * return self.get_memview() - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_5array_7memview___get__(((struct __pyx_array_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); - - /* "View.MemoryView":221 - * @property - * def memview(self): - * return self.get_memview() # <<<<<<<<<<<<<< - * - * @cname('get_memview') - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = ((struct __pyx_vtabstruct_array *)__pyx_v_self->__pyx_vtab)->get_memview(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 221, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "View.MemoryView":219 - * PyObject_Free(self._shape) - * - * @property # <<<<<<<<<<<<<< - * def memview(self): - * return self.get_memview() - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.array.memview.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":224 - * - * @cname('get_memview') - * cdef get_memview(self): # <<<<<<<<<<<<<< - * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE - * return memoryview(self, flags, self.dtype_is_object) - */ - -static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) { - int __pyx_v_flags; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_memview", 0); - - /* "View.MemoryView":225 - * @cname('get_memview') - * cdef get_memview(self): - * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE # <<<<<<<<<<<<<< - * return memoryview(self, flags, self.dtype_is_object) - * - */ - __pyx_v_flags = ((PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) | PyBUF_WRITABLE); - - /* "View.MemoryView":226 - * cdef get_memview(self): - * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE - * return memoryview(self, flags, self.dtype_is_object) # <<<<<<<<<<<<<< - * - * def __len__(self): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 226, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 226, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 226, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF((PyObject *)__pyx_v_self); - __Pyx_GIVEREF((PyObject *)__pyx_v_self); - PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self)); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); - __pyx_t_1 = 0; - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 226, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":224 - * - * @cname('get_memview') - * cdef get_memview(self): # <<<<<<<<<<<<<< - * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE - * return memoryview(self, flags, self.dtype_is_object) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.array.get_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":228 - * return memoryview(self, flags, self.dtype_is_object) - * - * def __len__(self): # <<<<<<<<<<<<<< - * return self._shape[0] - * - */ - -/* Python wrapper */ -static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self); /*proto*/ -static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - Py_ssize_t __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); - __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(((struct __pyx_array_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self) { - Py_ssize_t __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__len__", 0); - - /* "View.MemoryView":229 - * - * def __len__(self): - * return self._shape[0] # <<<<<<<<<<<<<< - * - * def __getattr__(self, attr): - */ - __pyx_r = (__pyx_v_self->_shape[0]); - goto __pyx_L0; - - /* "View.MemoryView":228 - * return memoryview(self, flags, self.dtype_is_object) - * - * def __len__(self): # <<<<<<<<<<<<<< - * return self._shape[0] - * - */ - - /* function exit code */ - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":231 - * return self._shape[0] - * - * def __getattr__(self, attr): # <<<<<<<<<<<<<< - * return getattr(self.memview, attr) - * - */ - -/* Python wrapper */ -static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr); /*proto*/ -static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0); - __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_attr)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__getattr__", 0); - - /* "View.MemoryView":232 - * - * def __getattr__(self, attr): - * return getattr(self.memview, attr) # <<<<<<<<<<<<<< - * - * def __getitem__(self, item): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 232, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_GetAttr(__pyx_t_1, __pyx_v_attr); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 232, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":231 - * return self._shape[0] - * - * def __getattr__(self, attr): # <<<<<<<<<<<<<< - * return getattr(self.memview, attr) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.array.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":234 - * return getattr(self.memview, attr) - * - * def __getitem__(self, item): # <<<<<<<<<<<<<< - * return self.memview[item] - * - */ - -/* Python wrapper */ -static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item); /*proto*/ -static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); - __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__getitem__", 0); - - /* "View.MemoryView":235 - * - * def __getitem__(self, item): - * return self.memview[item] # <<<<<<<<<<<<<< - * - * def __setitem__(self, item, value): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":234 - * return getattr(self.memview, attr) - * - * def __getitem__(self, item): # <<<<<<<<<<<<<< - * return self.memview[item] - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":237 - * return self.memview[item] - * - * def __setitem__(self, item, value): # <<<<<<<<<<<<<< - * self.memview[item] = value - * - */ - -/* Python wrapper */ -static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /*proto*/ -static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); - __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item), ((PyObject *)__pyx_v_value)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { - int __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setitem__", 0); - - /* "View.MemoryView":238 - * - * def __setitem__(self, item, value): - * self.memview[item] = value # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 238, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_v_item, __pyx_v_value) < 0))) __PYX_ERR(1, 238, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "View.MemoryView":237 - * return self.memview[item] - * - * def __setitem__(self, item, value): # <<<<<<<<<<<<<< - * self.memview[item] = value - * - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - * def __setstate_cython__(self, __pyx_state): - */ - -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; - __pyx_r = __pyx_pf___pyx_array___reduce_cython__(((struct __pyx_array_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__reduce_cython__", 0); - - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - */ - __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); - __PYX_ERR(1, 2, __pyx_L1_error) - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - * def __setstate_cython__(self, __pyx_state): - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("View.MemoryView.array.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - */ - -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; - PyObject* values[1] = {0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) kw_args--; - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v___pyx_state = values[0]; - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf___pyx_array_2__setstate_cython__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v___pyx_state); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 0); - - /* "(tree fragment)":4 - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - * def __setstate_cython__(self, __pyx_state): - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< - */ - __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); - __PYX_ERR(1, 4, __pyx_L1_error) - - /* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":248 - * - * @cname("__pyx_array_allocate_buffer") - * cdef int _allocate_buffer(array self) except -1: # <<<<<<<<<<<<<< - * - * - */ - -static int __pyx_array_allocate_buffer(struct __pyx_array_obj *__pyx_v_self) { - Py_ssize_t __pyx_v_i; - PyObject **__pyx_v_p; - int __pyx_r; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - Py_ssize_t __pyx_t_2; - Py_ssize_t __pyx_t_3; - Py_ssize_t __pyx_t_4; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_allocate_buffer", 0); - - /* "View.MemoryView":254 - * cdef PyObject **p - * - * self.free_data = True # <<<<<<<<<<<<<< - * self.data = malloc(self.len) - * if not self.data: - */ - __pyx_v_self->free_data = 1; - - /* "View.MemoryView":255 - * - * self.free_data = True - * self.data = malloc(self.len) # <<<<<<<<<<<<<< - * if not self.data: - * raise MemoryError, "unable to allocate array data." - */ - __pyx_v_self->data = ((char *)malloc(__pyx_v_self->len)); - - /* "View.MemoryView":256 - * self.free_data = True - * self.data = malloc(self.len) - * if not self.data: # <<<<<<<<<<<<<< - * raise MemoryError, "unable to allocate array data." - * - */ - __pyx_t_1 = (!(__pyx_v_self->data != 0)); - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":257 - * self.data = malloc(self.len) - * if not self.data: - * raise MemoryError, "unable to allocate array data." # <<<<<<<<<<<<<< - * - * if self.dtype_is_object: - */ - __Pyx_Raise(__pyx_builtin_MemoryError, __pyx_kp_s_unable_to_allocate_array_data, 0, 0); - __PYX_ERR(1, 257, __pyx_L1_error) - - /* "View.MemoryView":256 - * self.free_data = True - * self.data = malloc(self.len) - * if not self.data: # <<<<<<<<<<<<<< - * raise MemoryError, "unable to allocate array data." - * - */ - } - - /* "View.MemoryView":259 - * raise MemoryError, "unable to allocate array data." - * - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * p = self.data - * for i in range(self.len // self.itemsize): - */ - if (__pyx_v_self->dtype_is_object) { - - /* "View.MemoryView":260 - * - * if self.dtype_is_object: - * p = self.data # <<<<<<<<<<<<<< - * for i in range(self.len // self.itemsize): - * p[i] = Py_None - */ - __pyx_v_p = ((PyObject **)__pyx_v_self->data); - - /* "View.MemoryView":261 - * if self.dtype_is_object: - * p = self.data - * for i in range(self.len // self.itemsize): # <<<<<<<<<<<<<< - * p[i] = Py_None - * Py_INCREF(Py_None) - */ - if (unlikely(__pyx_v_self->itemsize == 0)) { - PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); - __PYX_ERR(1, 261, __pyx_L1_error) - } - else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_self->itemsize == (Py_ssize_t)-1) && unlikely(__Pyx_UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) { - PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); - __PYX_ERR(1, 261, __pyx_L1_error) - } - __pyx_t_2 = __Pyx_div_Py_ssize_t(__pyx_v_self->len, __pyx_v_self->itemsize); - __pyx_t_3 = __pyx_t_2; - for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { - __pyx_v_i = __pyx_t_4; - - /* "View.MemoryView":262 - * p = self.data - * for i in range(self.len // self.itemsize): - * p[i] = Py_None # <<<<<<<<<<<<<< - * Py_INCREF(Py_None) - * return 0 - */ - (__pyx_v_p[__pyx_v_i]) = Py_None; - - /* "View.MemoryView":263 - * for i in range(self.len // self.itemsize): - * p[i] = Py_None - * Py_INCREF(Py_None) # <<<<<<<<<<<<<< - * return 0 - * - */ - Py_INCREF(Py_None); - } - - /* "View.MemoryView":259 - * raise MemoryError, "unable to allocate array data." - * - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * p = self.data - * for i in range(self.len // self.itemsize): - */ - } - - /* "View.MemoryView":264 - * p[i] = Py_None - * Py_INCREF(Py_None) - * return 0 # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = 0; - goto __pyx_L0; - - /* "View.MemoryView":248 - * - * @cname("__pyx_array_allocate_buffer") - * cdef int _allocate_buffer(array self) except -1: # <<<<<<<<<<<<<< - * - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("View.MemoryView._allocate_buffer", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":268 - * - * @cname("__pyx_array_new") - * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, char *c_mode, char *buf): # <<<<<<<<<<<<<< - * cdef array result - * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. - */ - -static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, char *__pyx_v_format, char *__pyx_v_c_mode, char *__pyx_v_buf) { - struct __pyx_array_obj *__pyx_v_result = 0; - PyObject *__pyx_v_mode = 0; - struct __pyx_array_obj *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("array_cwrapper", 0); - - /* "View.MemoryView":270 - * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, char *c_mode, char *buf): - * cdef array result - * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. # <<<<<<<<<<<<<< - * - * if buf is NULL: - */ - if (((__pyx_v_c_mode[0]) == 'f')) { - __Pyx_INCREF(__pyx_n_s_fortran); - __pyx_t_1 = __pyx_n_s_fortran; - } else { - __Pyx_INCREF(__pyx_n_s_c); - __pyx_t_1 = __pyx_n_s_c; - } - __pyx_v_mode = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - /* "View.MemoryView":272 - * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. - * - * if buf is NULL: # <<<<<<<<<<<<<< - * result = array.__new__(array, shape, itemsize, format, mode) - * else: - */ - __pyx_t_2 = (__pyx_v_buf == NULL); - if (__pyx_t_2) { - - /* "View.MemoryView":273 - * - * if buf is NULL: - * result = array.__new__(array, shape, itemsize, format, mode) # <<<<<<<<<<<<<< - * else: - * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) - */ - __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 273, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 273, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 273, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_INCREF(__pyx_v_shape); - __Pyx_GIVEREF(__pyx_v_shape); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_shape); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3); - __Pyx_INCREF(__pyx_v_mode); - __Pyx_GIVEREF(__pyx_v_mode); - PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_v_mode); - __pyx_t_1 = 0; - __pyx_t_3 = 0; - __pyx_t_3 = ((PyObject *)__pyx_tp_new_array(((PyTypeObject *)__pyx_array_type), __pyx_t_4, NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 273, __pyx_L1_error) - __Pyx_GOTREF((PyObject *)__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_3); - __pyx_t_3 = 0; - - /* "View.MemoryView":272 - * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. - * - * if buf is NULL: # <<<<<<<<<<<<<< - * result = array.__new__(array, shape, itemsize, format, mode) - * else: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":275 - * result = array.__new__(array, shape, itemsize, format, mode) - * else: - * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) # <<<<<<<<<<<<<< - * result.data = buf - * - */ - /*else*/ { - __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 275, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 275, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 275, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_shape); - __Pyx_GIVEREF(__pyx_v_shape); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_shape); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_t_4); - __Pyx_INCREF(__pyx_v_mode); - __Pyx_GIVEREF(__pyx_v_mode); - PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_v_mode); - __pyx_t_3 = 0; - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 275, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_allocate_buffer, Py_False) < 0) __PYX_ERR(1, 275, __pyx_L1_error) - __pyx_t_3 = ((PyObject *)__pyx_tp_new_array(((PyTypeObject *)__pyx_array_type), __pyx_t_1, __pyx_t_4)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 275, __pyx_L1_error) - __Pyx_GOTREF((PyObject *)__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_3); - __pyx_t_3 = 0; - - /* "View.MemoryView":276 - * else: - * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) - * result.data = buf # <<<<<<<<<<<<<< - * - * return result - */ - __pyx_v_result->data = __pyx_v_buf; - } - __pyx_L3:; - - /* "View.MemoryView":278 - * result.data = buf - * - * return result # <<<<<<<<<<<<<< - * - * - */ - __Pyx_XDECREF((PyObject *)__pyx_r); - __Pyx_INCREF((PyObject *)__pyx_v_result); - __pyx_r = __pyx_v_result; - goto __pyx_L0; - - /* "View.MemoryView":268 - * - * @cname("__pyx_array_new") - * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, char *c_mode, char *buf): # <<<<<<<<<<<<<< - * cdef array result - * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_result); - __Pyx_XDECREF(__pyx_v_mode); - __Pyx_XGIVEREF((PyObject *)__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":304 - * cdef class Enum(object): - * cdef object name - * def __init__(self, name): # <<<<<<<<<<<<<< - * self.name = name - * def __repr__(self): - */ - -/* Python wrapper */ -static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_name = 0; - CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; - PyObject* values[1] = {0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) kw_args--; - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 304, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(1, 304, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - } - __pyx_v_name = values[0]; - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 304, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("View.MemoryView.Enum.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return -1; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v_name); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name) { - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__", 0); - - /* "View.MemoryView":305 - * cdef object name - * def __init__(self, name): - * self.name = name # <<<<<<<<<<<<<< - * def __repr__(self): - * return self.name - */ - __Pyx_INCREF(__pyx_v_name); - __Pyx_GIVEREF(__pyx_v_name); - __Pyx_GOTREF(__pyx_v_self->name); - __Pyx_DECREF(__pyx_v_self->name); - __pyx_v_self->name = __pyx_v_name; - - /* "View.MemoryView":304 - * cdef class Enum(object): - * cdef object name - * def __init__(self, name): # <<<<<<<<<<<<<< - * self.name = name - * def __repr__(self): - */ - - /* function exit code */ - __pyx_r = 0; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":306 - * def __init__(self, name): - * self.name = name - * def __repr__(self): # <<<<<<<<<<<<<< - * return self.name - * - */ - -/* Python wrapper */ -static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); - __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__repr__", 0); - - /* "View.MemoryView":307 - * self.name = name - * def __repr__(self): - * return self.name # <<<<<<<<<<<<<< - * - * cdef generic = Enum(" ") - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->name); - __pyx_r = __pyx_v_self->name; - goto __pyx_L0; - - /* "View.MemoryView":306 - * def __init__(self, name): - * self.name = name - * def __repr__(self): # <<<<<<<<<<<<<< - * return self.name - * - */ - - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ - -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; - __pyx_r = __pyx_pf___pyx_MemviewEnum___reduce_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { - PyObject *__pyx_v_state = 0; - PyObject *__pyx_v__dict = 0; - int __pyx_v_use_setstate; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__reduce_cython__", 0); - - /* "(tree fragment)":5 - * cdef object _dict - * cdef bint use_setstate - * state = (self.name,) # <<<<<<<<<<<<<< - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - */ - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_self->name); - __Pyx_GIVEREF(__pyx_v_self->name); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name); - __pyx_v_state = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - /* "(tree fragment)":6 - * cdef bint use_setstate - * state = (self.name,) - * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< - * if _dict is not None: - * state += (_dict,) - */ - __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v__dict = __pyx_t_1; - __pyx_t_1 = 0; - - /* "(tree fragment)":7 - * state = (self.name,) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True - */ - __pyx_t_2 = (__pyx_v__dict != Py_None); - if (__pyx_t_2) { - - /* "(tree fragment)":8 - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - * state += (_dict,) # <<<<<<<<<<<<<< - * use_setstate = True - * else: - */ - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v__dict); - __Pyx_GIVEREF(__pyx_v__dict); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict); - __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); - __pyx_t_3 = 0; - - /* "(tree fragment)":9 - * if _dict is not None: - * state += (_dict,) - * use_setstate = True # <<<<<<<<<<<<<< - * else: - * use_setstate = self.name is not None - */ - __pyx_v_use_setstate = 1; - - /* "(tree fragment)":7 - * state = (self.name,) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True - */ - goto __pyx_L3; - } - - /* "(tree fragment)":11 - * use_setstate = True - * else: - * use_setstate = self.name is not None # <<<<<<<<<<<<<< - * if use_setstate: - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state - */ - /*else*/ { - __pyx_t_2 = (__pyx_v_self->name != Py_None); - __pyx_v_use_setstate = __pyx_t_2; - } - __pyx_L3:; - - /* "(tree fragment)":12 - * else: - * use_setstate = self.name is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state - * else: - */ - if (__pyx_v_use_setstate) { - - /* "(tree fragment)":13 - * use_setstate = self.name is not None - * if use_setstate: - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state # <<<<<<<<<<<<<< - * else: - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_136983863); - __Pyx_GIVEREF(__pyx_int_136983863); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_136983863); - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None); - __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state); - __pyx_t_3 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; - goto __pyx_L0; - - /* "(tree fragment)":12 - * else: - * use_setstate = self.name is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state - * else: - */ - } - - /* "(tree fragment)":15 - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state - * else: - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_Enum__set_state(self, __pyx_state) - */ - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_136983863); - __Pyx_GIVEREF(__pyx_int_136983863); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_136983863); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); - __pyx_t_4 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L0; - } - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("View.MemoryView.Enum.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_state); - __Pyx_XDECREF(__pyx_v__dict); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":16 - * else: - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_Enum__set_state(self, __pyx_state) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - PyObject *__pyx_v___pyx_state = 0; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; - PyObject* values[1] = {0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) kw_args--; - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 16, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 16, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v___pyx_state = values[0]; - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v___pyx_state); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 0); - - /* "(tree fragment)":17 - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_Enum__set_state(self, __pyx_state) # <<<<<<<<<<<<<< - */ - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 17, __pyx_L1_error) - __pyx_t_1 = __pyx_unpickle_Enum__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "(tree fragment)":16 - * else: - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_Enum__set_state(self, __pyx_state) - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":349 - * cdef __Pyx_TypeInfo *typeinfo - * - * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< - * self.obj = obj - * self.flags = flags - */ - -/* Python wrapper */ -static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_obj = 0; - int __pyx_v_flags; - int __pyx_v_dtype_is_object; - CYTHON_UNUSED const Py_ssize_t __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_obj,&__pyx_n_s_flags,&__pyx_n_s_dtype_is_object,0}; - PyObject* values[3] = {0,0,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_obj)) != 0)) kw_args--; - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_flags)) != 0)) kw_args--; - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(1, 349, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dtype_is_object); - if (value) { values[2] = value; kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(1, 349, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); - values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_obj = values[0]; - __pyx_v_flags = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error) - if (values[2]) { - __pyx_v_dtype_is_object = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_dtype_is_object == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error) - } else { - __pyx_v_dtype_is_object = ((int)0); - } - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, __pyx_nargs); __PYX_ERR(1, 349, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return -1; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_obj, __pyx_v_flags, __pyx_v_dtype_is_object); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object) { - int __pyx_r; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - Py_intptr_t __pyx_t_4; - size_t __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__cinit__", 0); - - /* "View.MemoryView":350 - * - * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): - * self.obj = obj # <<<<<<<<<<<<<< - * self.flags = flags - * if type(self) is memoryview or obj is not None: - */ - __Pyx_INCREF(__pyx_v_obj); - __Pyx_GIVEREF(__pyx_v_obj); - __Pyx_GOTREF(__pyx_v_self->obj); - __Pyx_DECREF(__pyx_v_self->obj); - __pyx_v_self->obj = __pyx_v_obj; - - /* "View.MemoryView":351 - * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): - * self.obj = obj - * self.flags = flags # <<<<<<<<<<<<<< - * if type(self) is memoryview or obj is not None: - * __Pyx_GetBuffer(obj, &self.view, flags) - */ - __pyx_v_self->flags = __pyx_v_flags; - - /* "View.MemoryView":352 - * self.obj = obj - * self.flags = flags - * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< - * __Pyx_GetBuffer(obj, &self.view, flags) - * if self.view.obj == NULL: - */ - __pyx_t_2 = (((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))) == ((PyObject *)__pyx_memoryview_type)); - if (!__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_2 = (__pyx_v_obj != Py_None); - __pyx_t_1 = __pyx_t_2; - __pyx_L4_bool_binop_done:; - if (__pyx_t_1) { - - /* "View.MemoryView":353 - * self.flags = flags - * if type(self) is memoryview or obj is not None: - * __Pyx_GetBuffer(obj, &self.view, flags) # <<<<<<<<<<<<<< - * if self.view.obj == NULL: - * (<__pyx_buffer *> &self.view).obj = Py_None - */ - __pyx_t_3 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 353, __pyx_L1_error) - - /* "View.MemoryView":354 - * if type(self) is memoryview or obj is not None: - * __Pyx_GetBuffer(obj, &self.view, flags) - * if self.view.obj == NULL: # <<<<<<<<<<<<<< - * (<__pyx_buffer *> &self.view).obj = Py_None - * Py_INCREF(Py_None) - */ - __pyx_t_1 = (((PyObject *)__pyx_v_self->view.obj) == NULL); - if (__pyx_t_1) { - - /* "View.MemoryView":355 - * __Pyx_GetBuffer(obj, &self.view, flags) - * if self.view.obj == NULL: - * (<__pyx_buffer *> &self.view).obj = Py_None # <<<<<<<<<<<<<< - * Py_INCREF(Py_None) - * - */ - ((Py_buffer *)(&__pyx_v_self->view))->obj = Py_None; - - /* "View.MemoryView":356 - * if self.view.obj == NULL: - * (<__pyx_buffer *> &self.view).obj = Py_None - * Py_INCREF(Py_None) # <<<<<<<<<<<<<< - * - * if not __PYX_CYTHON_ATOMICS_ENABLED(): - */ - Py_INCREF(Py_None); - - /* "View.MemoryView":354 - * if type(self) is memoryview or obj is not None: - * __Pyx_GetBuffer(obj, &self.view, flags) - * if self.view.obj == NULL: # <<<<<<<<<<<<<< - * (<__pyx_buffer *> &self.view).obj = Py_None - * Py_INCREF(Py_None) - */ - } - - /* "View.MemoryView":352 - * self.obj = obj - * self.flags = flags - * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< - * __Pyx_GetBuffer(obj, &self.view, flags) - * if self.view.obj == NULL: - */ - } - - /* "View.MemoryView":358 - * Py_INCREF(Py_None) - * - * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< - * global __pyx_memoryview_thread_locks_used - * if __pyx_memoryview_thread_locks_used < 8: - */ - __pyx_t_1 = (!__PYX_CYTHON_ATOMICS_ENABLED()); - if (__pyx_t_1) { - - /* "View.MemoryView":360 - * if not __PYX_CYTHON_ATOMICS_ENABLED(): - * global __pyx_memoryview_thread_locks_used - * if __pyx_memoryview_thread_locks_used < 8: # <<<<<<<<<<<<<< - * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] - * __pyx_memoryview_thread_locks_used += 1 - */ - __pyx_t_1 = (__pyx_memoryview_thread_locks_used < 8); - if (__pyx_t_1) { - - /* "View.MemoryView":361 - * global __pyx_memoryview_thread_locks_used - * if __pyx_memoryview_thread_locks_used < 8: - * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] # <<<<<<<<<<<<<< - * __pyx_memoryview_thread_locks_used += 1 - * if self.lock is NULL: - */ - __pyx_v_self->lock = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); - - /* "View.MemoryView":362 - * if __pyx_memoryview_thread_locks_used < 8: - * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] - * __pyx_memoryview_thread_locks_used += 1 # <<<<<<<<<<<<<< - * if self.lock is NULL: - * self.lock = PyThread_allocate_lock() - */ - __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used + 1); - - /* "View.MemoryView":360 - * if not __PYX_CYTHON_ATOMICS_ENABLED(): - * global __pyx_memoryview_thread_locks_used - * if __pyx_memoryview_thread_locks_used < 8: # <<<<<<<<<<<<<< - * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] - * __pyx_memoryview_thread_locks_used += 1 - */ - } - - /* "View.MemoryView":363 - * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] - * __pyx_memoryview_thread_locks_used += 1 - * if self.lock is NULL: # <<<<<<<<<<<<<< - * self.lock = PyThread_allocate_lock() - * if self.lock is NULL: - */ - __pyx_t_1 = (__pyx_v_self->lock == NULL); - if (__pyx_t_1) { - - /* "View.MemoryView":364 - * __pyx_memoryview_thread_locks_used += 1 - * if self.lock is NULL: - * self.lock = PyThread_allocate_lock() # <<<<<<<<<<<<<< - * if self.lock is NULL: - * raise MemoryError - */ - __pyx_v_self->lock = PyThread_allocate_lock(); - - /* "View.MemoryView":365 - * if self.lock is NULL: - * self.lock = PyThread_allocate_lock() - * if self.lock is NULL: # <<<<<<<<<<<<<< - * raise MemoryError - * - */ - __pyx_t_1 = (__pyx_v_self->lock == NULL); - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":366 - * self.lock = PyThread_allocate_lock() - * if self.lock is NULL: - * raise MemoryError # <<<<<<<<<<<<<< - * - * if flags & PyBUF_FORMAT: - */ - PyErr_NoMemory(); __PYX_ERR(1, 366, __pyx_L1_error) - - /* "View.MemoryView":365 - * if self.lock is NULL: - * self.lock = PyThread_allocate_lock() - * if self.lock is NULL: # <<<<<<<<<<<<<< - * raise MemoryError - * - */ - } - - /* "View.MemoryView":363 - * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] - * __pyx_memoryview_thread_locks_used += 1 - * if self.lock is NULL: # <<<<<<<<<<<<<< - * self.lock = PyThread_allocate_lock() - * if self.lock is NULL: - */ - } - - /* "View.MemoryView":358 - * Py_INCREF(Py_None) - * - * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< - * global __pyx_memoryview_thread_locks_used - * if __pyx_memoryview_thread_locks_used < 8: - */ - } - - /* "View.MemoryView":368 - * raise MemoryError - * - * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< - * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') - * else: - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":369 - * - * if flags & PyBUF_FORMAT: - * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') # <<<<<<<<<<<<<< - * else: - * self.dtype_is_object = dtype_is_object - */ - __pyx_t_2 = ((__pyx_v_self->view.format[0]) == 'O'); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L12_bool_binop_done; - } - __pyx_t_2 = ((__pyx_v_self->view.format[1]) == '\x00'); - __pyx_t_1 = __pyx_t_2; - __pyx_L12_bool_binop_done:; - __pyx_v_self->dtype_is_object = __pyx_t_1; - - /* "View.MemoryView":368 - * raise MemoryError - * - * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< - * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') - * else: - */ - goto __pyx_L11; - } - - /* "View.MemoryView":371 - * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') - * else: - * self.dtype_is_object = dtype_is_object # <<<<<<<<<<<<<< - * - * assert self.view.buf - */ - -static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { - Py_ssize_t __pyx_v_dim; - char *__pyx_v_itemp; - PyObject *__pyx_v_idx = NULL; - char *__pyx_r; - __Pyx_RefNannyDeclarations - Py_ssize_t __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - Py_ssize_t __pyx_t_3; - PyObject *(*__pyx_t_4)(PyObject *); - PyObject *__pyx_t_5 = NULL; - Py_ssize_t __pyx_t_6; - char *__pyx_t_7; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_item_pointer", 0); - - /* "View.MemoryView":399 - * cdef char *get_item_pointer(memoryview self, object index) except NULL: - * cdef Py_ssize_t dim - * cdef char *itemp = self.view.buf # <<<<<<<<<<<<<< - * - * for dim, idx in enumerate(index): - */ - __pyx_v_itemp = ((char *)__pyx_v_self->view.buf); - - /* "View.MemoryView":401 - * cdef char *itemp = self.view.buf - * - * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< - * itemp = pybuffer_index(&self.view, itemp, idx, dim) - * - */ - __pyx_t_1 = 0; - if (likely(PyList_CheckExact(__pyx_v_index)) || PyTuple_CheckExact(__pyx_v_index)) { - __pyx_t_2 = __pyx_v_index; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; - __pyx_t_4 = NULL; - } else { - __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 401, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 401, __pyx_L1_error) - } - for (;;) { - if (likely(!__pyx_t_4)) { - if (likely(PyList_CheckExact(__pyx_t_2))) { - if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(1, 401, __pyx_L1_error) - #else - __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 401, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - #endif - } else { - if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(1, 401, __pyx_L1_error) - #else - __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 401, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - #endif - } - } else { - __pyx_t_5 = __pyx_t_4(__pyx_t_2); - if (unlikely(!__pyx_t_5)) { - PyObject* exc_type = PyErr_Occurred(); - if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 401, __pyx_L1_error) - } - break; - } - __Pyx_GOTREF(__pyx_t_5); - } - __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_5); - __pyx_t_5 = 0; - __pyx_v_dim = __pyx_t_1; - __pyx_t_1 = (__pyx_t_1 + 1); - - /* "View.MemoryView":402 - * - * for dim, idx in enumerate(index): - * itemp = pybuffer_index(&self.view, itemp, idx, dim) # <<<<<<<<<<<<<< - * - * return itemp - */ - __pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 402, __pyx_L1_error) - __pyx_t_7 = __pyx_pybuffer_index((&__pyx_v_self->view), __pyx_v_itemp, __pyx_t_6, __pyx_v_dim); if (unlikely(__pyx_t_7 == ((char *)NULL))) __PYX_ERR(1, 402, __pyx_L1_error) - __pyx_v_itemp = __pyx_t_7; - - /* "View.MemoryView":401 - * cdef char *itemp = self.view.buf - * - * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< - * itemp = pybuffer_index(&self.view, itemp, idx, dim) - * - */ - } - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "View.MemoryView":404 - * itemp = pybuffer_index(&self.view, itemp, idx, dim) - * - * return itemp # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = __pyx_v_itemp; - goto __pyx_L0; - - /* "View.MemoryView":397 - * PyThread_free_lock(self.lock) - * - * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< - * cdef Py_ssize_t dim - * cdef char *itemp = self.view.buf - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("View.MemoryView.memoryview.get_item_pointer", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_idx); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":407 - * - * - * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< - * if index is Ellipsis: - * return self - */ - -/* Python wrapper */ -static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index); /*proto*/ -static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { - PyObject *__pyx_v_have_slices = NULL; - PyObject *__pyx_v_indices = NULL; - char *__pyx_v_itemp; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - char *__pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__getitem__", 0); - - /* "View.MemoryView":408 - * - * def __getitem__(memoryview self, object index): - * if index is Ellipsis: # <<<<<<<<<<<<<< - * return self - * - */ - __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis); - if (__pyx_t_1) { - - /* "View.MemoryView":409 - * def __getitem__(memoryview self, object index): - * if index is Ellipsis: - * return self # <<<<<<<<<<<<<< - * - * have_slices, indices = _unellipsify(index, self.view.ndim) - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF((PyObject *)__pyx_v_self); - __pyx_r = ((PyObject *)__pyx_v_self); - goto __pyx_L0; - - /* "View.MemoryView":408 - * - * def __getitem__(memoryview self, object index): - * if index is Ellipsis: # <<<<<<<<<<<<<< - * return self - * - */ - } - - /* "View.MemoryView":411 - * return self - * - * have_slices, indices = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< - * - * cdef char *itemp - */ - __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 411, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (likely(__pyx_t_2 != Py_None)) { - PyObject* sequence = __pyx_t_2; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 411, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(__pyx_t_4); - #else - __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 411, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 411, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } else { - __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 411, __pyx_L1_error) - } - __pyx_v_have_slices = __pyx_t_3; - __pyx_t_3 = 0; - __pyx_v_indices = __pyx_t_4; - __pyx_t_4 = 0; - - /* "View.MemoryView":414 - * - * cdef char *itemp - * if have_slices: # <<<<<<<<<<<<<< - * return memview_slice(self, indices) - * else: - */ - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 414, __pyx_L1_error) - if (__pyx_t_1) { - - /* "View.MemoryView":415 - * cdef char *itemp - * if have_slices: - * return memview_slice(self, indices) # <<<<<<<<<<<<<< - * else: - * itemp = self.get_item_pointer(indices) - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 415, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":414 - * - * cdef char *itemp - * if have_slices: # <<<<<<<<<<<<<< - * return memview_slice(self, indices) - * else: - */ - } - - /* "View.MemoryView":417 - * return memview_slice(self, indices) - * else: - * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<< - * return self.convert_item_to_object(itemp) - * - */ - /*else*/ { - __pyx_t_5 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_5 == ((char *)NULL))) __PYX_ERR(1, 417, __pyx_L1_error) - __pyx_v_itemp = __pyx_t_5; - - /* "View.MemoryView":418 - * else: - * itemp = self.get_item_pointer(indices) - * return self.convert_item_to_object(itemp) # <<<<<<<<<<<<<< - * - * def __setitem__(memoryview self, object index, object value): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 418, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - } - - /* "View.MemoryView":407 - * - * - * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< - * if index is Ellipsis: - * return self - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("View.MemoryView.memoryview.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_have_slices); - __Pyx_XDECREF(__pyx_v_indices); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":420 - * return self.convert_item_to_object(itemp) - * - * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< - * if self.view.readonly: - * raise TypeError, "Cannot assign to read-only memoryview" - */ - -/* Python wrapper */ -static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /*proto*/ -static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index), ((PyObject *)__pyx_v_value)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { - PyObject *__pyx_v_have_slices = NULL; - PyObject *__pyx_v_obj = NULL; - int __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setitem__", 0); - __Pyx_INCREF(__pyx_v_index); - - /* "View.MemoryView":421 - * - * def __setitem__(memoryview self, object index, object value): - * if self.view.readonly: # <<<<<<<<<<<<<< - * raise TypeError, "Cannot assign to read-only memoryview" - * - */ - if (unlikely(__pyx_v_self->view.readonly)) { - - /* "View.MemoryView":422 - * def __setitem__(memoryview self, object index, object value): - * if self.view.readonly: - * raise TypeError, "Cannot assign to read-only memoryview" # <<<<<<<<<<<<<< - * - * have_slices, index = _unellipsify(index, self.view.ndim) - */ - __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_Cannot_assign_to_read_only_memor, 0, 0); - __PYX_ERR(1, 422, __pyx_L1_error) - - /* "View.MemoryView":421 - * - * def __setitem__(memoryview self, object index, object value): - * if self.view.readonly: # <<<<<<<<<<<<<< - * raise TypeError, "Cannot assign to read-only memoryview" - * - */ - } - - /* "View.MemoryView":424 - * raise TypeError, "Cannot assign to read-only memoryview" - * - * have_slices, index = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< - * - * if have_slices: - */ - __pyx_t_1 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 424, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (likely(__pyx_t_1 != Py_None)) { - PyObject* sequence = __pyx_t_1; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 424, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - #else - __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 424, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 424, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } else { - __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 424, __pyx_L1_error) - } - __pyx_v_have_slices = __pyx_t_2; - __pyx_t_2 = 0; - __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_3); - __pyx_t_3 = 0; - - /* "View.MemoryView":426 - * have_slices, index = _unellipsify(index, self.view.ndim) - * - * if have_slices: # <<<<<<<<<<<<<< - * obj = self.is_slice(value) - * if obj: - */ - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(1, 426, __pyx_L1_error) - if (__pyx_t_4) { - - /* "View.MemoryView":427 - * - * if have_slices: - * obj = self.is_slice(value) # <<<<<<<<<<<<<< - * if obj: - * self.setitem_slice_assignment(self[index], obj) - */ - __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 427, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_obj = __pyx_t_1; - __pyx_t_1 = 0; - - /* "View.MemoryView":428 - * if have_slices: - * obj = self.is_slice(value) - * if obj: # <<<<<<<<<<<<<< - * self.setitem_slice_assignment(self[index], obj) - * else: - */ - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_obj); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(1, 428, __pyx_L1_error) - if (__pyx_t_4) { - - /* "View.MemoryView":429 - * obj = self.is_slice(value) - * if obj: - * self.setitem_slice_assignment(self[index], obj) # <<<<<<<<<<<<<< - * else: - * self.setitem_slice_assign_scalar(self[index], value) - */ - __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 429, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_1, __pyx_v_obj); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 429, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "View.MemoryView":428 - * if have_slices: - * obj = self.is_slice(value) - * if obj: # <<<<<<<<<<<<<< - * self.setitem_slice_assignment(self[index], obj) - * else: - */ - goto __pyx_L5; - } - - /* "View.MemoryView":431 - * self.setitem_slice_assignment(self[index], obj) - * else: - * self.setitem_slice_assign_scalar(self[index], value) # <<<<<<<<<<<<<< - * else: - * self.setitem_indexed(index, value) - */ - /*else*/ { - __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 431, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(1, 431, __pyx_L1_error) - __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_3), __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 431, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } - __pyx_L5:; - - /* "View.MemoryView":426 - * have_slices, index = _unellipsify(index, self.view.ndim) - * - * if have_slices: # <<<<<<<<<<<<<< - * obj = self.is_slice(value) - * if obj: - */ - goto __pyx_L4; - } - - /* "View.MemoryView":433 - * self.setitem_slice_assign_scalar(self[index], value) - * else: - * self.setitem_indexed(index, value) # <<<<<<<<<<<<<< - * - * cdef is_slice(self, obj): - */ - /*else*/ { - __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 433, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } - __pyx_L4:; - - /* "View.MemoryView":420 - * return self.convert_item_to_object(itemp) - * - * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< - * if self.view.readonly: - * raise TypeError, "Cannot assign to read-only memoryview" - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.memoryview.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_have_slices); - __Pyx_XDECREF(__pyx_v_obj); - __Pyx_XDECREF(__pyx_v_index); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":435 - * self.setitem_indexed(index, value) - * - * cdef is_slice(self, obj): # <<<<<<<<<<<<<< - * if not isinstance(obj, memoryview): - * try: - */ - -static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - int __pyx_t_9; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("is_slice", 0); - __Pyx_INCREF(__pyx_v_obj); - - /* "View.MemoryView":436 - * - * cdef is_slice(self, obj): - * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< - * try: - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - */ - __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_obj, __pyx_memoryview_type); - __pyx_t_2 = (!__pyx_t_1); - if (__pyx_t_2) { - - /* "View.MemoryView":437 - * cdef is_slice(self, obj): - * if not isinstance(obj, memoryview): - * try: # <<<<<<<<<<<<<< - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - * self.dtype_is_object) - */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); - __Pyx_XGOTREF(__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_4); - __Pyx_XGOTREF(__pyx_t_5); - /*try:*/ { - - /* "View.MemoryView":438 - * if not isinstance(obj, memoryview): - * try: - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< - * self.dtype_is_object) - * except TypeError: - */ - __pyx_t_6 = __Pyx_PyInt_From_int(((__pyx_v_self->flags & (~PyBUF_WRITABLE)) | PyBUF_ANY_CONTIGUOUS)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 438, __pyx_L4_error) - __Pyx_GOTREF(__pyx_t_6); - - /* "View.MemoryView":439 - * try: - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - * self.dtype_is_object) # <<<<<<<<<<<<<< - * except TypeError: - * return None - */ - __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 439, __pyx_L4_error) - __Pyx_GOTREF(__pyx_t_7); - - /* "View.MemoryView":438 - * if not isinstance(obj, memoryview): - * try: - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< - * self.dtype_is_object) - * except TypeError: - */ - __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 438, __pyx_L4_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_INCREF(__pyx_v_obj); - __Pyx_GIVEREF(__pyx_v_obj); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_obj); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7); - __pyx_t_6 = 0; - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 438, __pyx_L4_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF_SET(__pyx_v_obj, __pyx_t_7); - __pyx_t_7 = 0; - - /* "View.MemoryView":437 - * cdef is_slice(self, obj): - * if not isinstance(obj, memoryview): - * try: # <<<<<<<<<<<<<< - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - * self.dtype_is_object) - */ - } - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - goto __pyx_L9_try_end; - __pyx_L4_error:; - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - - /* "View.MemoryView":440 - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - * self.dtype_is_object) - * except TypeError: # <<<<<<<<<<<<<< - * return None - * - */ - __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); - if (__pyx_t_9) { - __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_6) < 0) __PYX_ERR(1, 440, __pyx_L6_except_error) - __Pyx_XGOTREF(__pyx_t_7); - __Pyx_XGOTREF(__pyx_t_8); - __Pyx_XGOTREF(__pyx_t_6); - - /* "View.MemoryView":441 - * self.dtype_is_object) - * except TypeError: - * return None # <<<<<<<<<<<<<< - * - * return obj - */ - __Pyx_XDECREF(__pyx_r); - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - goto __pyx_L7_except_return; - } - goto __pyx_L6_except_error; - - /* "View.MemoryView":437 - * cdef is_slice(self, obj): - * if not isinstance(obj, memoryview): - * try: # <<<<<<<<<<<<<< - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - * self.dtype_is_object) - */ - __pyx_L6_except_error:; - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_XGIVEREF(__pyx_t_4); - __Pyx_XGIVEREF(__pyx_t_5); - __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); - goto __pyx_L1_error; - __pyx_L7_except_return:; - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_XGIVEREF(__pyx_t_4); - __Pyx_XGIVEREF(__pyx_t_5); - __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); - goto __pyx_L0; - __pyx_L9_try_end:; - } - - /* "View.MemoryView":436 - * - * cdef is_slice(self, obj): - * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< - * try: - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - */ - } - - /* "View.MemoryView":443 - * return None - * - * return obj # <<<<<<<<<<<<<< - * - * cdef setitem_slice_assignment(self, dst, src): - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_obj); - __pyx_r = __pyx_v_obj; - goto __pyx_L0; - - /* "View.MemoryView":435 - * self.setitem_indexed(index, value) - * - * cdef is_slice(self, obj): # <<<<<<<<<<<<<< - * if not isinstance(obj, memoryview): - * try: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_obj); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":445 - * return obj - * - * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice dst_slice - * cdef __Pyx_memviewslice src_slice - */ - -static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src) { - __Pyx_memviewslice __pyx_v_dst_slice; - __Pyx_memviewslice __pyx_v_src_slice; - __Pyx_memviewslice __pyx_v_msrc; - __Pyx_memviewslice __pyx_v_mdst; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_memviewslice *__pyx_t_1; - PyObject *__pyx_t_2 = NULL; - int __pyx_t_3; - int __pyx_t_4; - int __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("setitem_slice_assignment", 0); - - /* "View.MemoryView":448 - * cdef __Pyx_memviewslice dst_slice - * cdef __Pyx_memviewslice src_slice - * cdef __Pyx_memviewslice msrc = get_slice_from_memview(src, &src_slice)[0] # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] - * - */ - if (!(likely(((__pyx_v_src) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_src, __pyx_memoryview_type))))) __PYX_ERR(1, 448, __pyx_L1_error) - __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_src), (&__pyx_v_src_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 448, __pyx_L1_error) - __pyx_v_msrc = (__pyx_t_1[0]); - - /* "View.MemoryView":449 - * cdef __Pyx_memviewslice src_slice - * cdef __Pyx_memviewslice msrc = get_slice_from_memview(src, &src_slice)[0] - * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] # <<<<<<<<<<<<<< - * - * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) - */ - if (!(likely(((__pyx_v_dst) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_dst, __pyx_memoryview_type))))) __PYX_ERR(1, 449, __pyx_L1_error) - __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 449, __pyx_L1_error) - __pyx_v_mdst = (__pyx_t_1[0]); - - /* "View.MemoryView":451 - * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] - * - * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) # <<<<<<<<<<<<<< - * - * cdef setitem_slice_assign_scalar(self, memoryview dst, value): - */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 451, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 451, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 451, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 451, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_5 = __pyx_memoryview_copy_contents(__pyx_v_msrc, __pyx_v_mdst, __pyx_t_3, __pyx_t_4, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 451, __pyx_L1_error) - - /* "View.MemoryView":445 - * return obj - * - * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice dst_slice - * cdef __Pyx_memviewslice src_slice - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assignment", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":453 - * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) - * - * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< - * cdef int array[128] - * cdef void *tmp = NULL - */ - -static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value) { - int __pyx_v_array[0x80]; - void *__pyx_v_tmp; - void *__pyx_v_item; - __Pyx_memviewslice *__pyx_v_dst_slice; - __Pyx_memviewslice __pyx_v_tmp_slice; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_memviewslice *__pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - int __pyx_t_5; - char const *__pyx_t_6; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - PyObject *__pyx_t_9 = NULL; - PyObject *__pyx_t_10 = NULL; - PyObject *__pyx_t_11 = NULL; - PyObject *__pyx_t_12 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("setitem_slice_assign_scalar", 0); - - /* "View.MemoryView":455 - * cdef setitem_slice_assign_scalar(self, memoryview dst, value): - * cdef int array[128] - * cdef void *tmp = NULL # <<<<<<<<<<<<<< - * cdef void *item - * - */ - __pyx_v_tmp = NULL; - - /* "View.MemoryView":460 - * cdef __Pyx_memviewslice *dst_slice - * cdef __Pyx_memviewslice tmp_slice - * dst_slice = get_slice_from_memview(dst, &tmp_slice) # <<<<<<<<<<<<<< - * - * if self.view.itemsize > sizeof(array): - */ - __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_dst, (&__pyx_v_tmp_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 460, __pyx_L1_error) - __pyx_v_dst_slice = __pyx_t_1; - - /* "View.MemoryView":462 - * dst_slice = get_slice_from_memview(dst, &tmp_slice) - * - * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< - * tmp = PyMem_Malloc(self.view.itemsize) - * if tmp == NULL: - */ - __pyx_t_2 = (((size_t)__pyx_v_self->view.itemsize) > (sizeof(__pyx_v_array))); - if (__pyx_t_2) { - - /* "View.MemoryView":463 - * - * if self.view.itemsize > sizeof(array): - * tmp = PyMem_Malloc(self.view.itemsize) # <<<<<<<<<<<<<< - * if tmp == NULL: - * raise MemoryError - */ - __pyx_v_tmp = PyMem_Malloc(__pyx_v_self->view.itemsize); - - /* "View.MemoryView":464 - * if self.view.itemsize > sizeof(array): - * tmp = PyMem_Malloc(self.view.itemsize) - * if tmp == NULL: # <<<<<<<<<<<<<< - * raise MemoryError - * item = tmp - */ - __pyx_t_2 = (__pyx_v_tmp == NULL); - if (unlikely(__pyx_t_2)) { - - /* "View.MemoryView":465 - * tmp = PyMem_Malloc(self.view.itemsize) - * if tmp == NULL: - * raise MemoryError # <<<<<<<<<<<<<< - * item = tmp - * else: - */ - PyErr_NoMemory(); __PYX_ERR(1, 465, __pyx_L1_error) - - /* "View.MemoryView":464 - * if self.view.itemsize > sizeof(array): - * tmp = PyMem_Malloc(self.view.itemsize) - * if tmp == NULL: # <<<<<<<<<<<<<< - * raise MemoryError - * item = tmp - */ - } - - /* "View.MemoryView":466 - * if tmp == NULL: - * raise MemoryError - * item = tmp # <<<<<<<<<<<<<< - * else: - * item = array - */ - __pyx_v_item = __pyx_v_tmp; - - /* "View.MemoryView":462 - * dst_slice = get_slice_from_memview(dst, &tmp_slice) - * - * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< - * tmp = PyMem_Malloc(self.view.itemsize) - * if tmp == NULL: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":468 - * item = tmp - * else: - * item = array # <<<<<<<<<<<<<< - * - * try: - */ - /*else*/ { - __pyx_v_item = ((void *)__pyx_v_array); - } - __pyx_L3:; - - /* "View.MemoryView":470 - * item = array - * - * try: # <<<<<<<<<<<<<< - * if self.dtype_is_object: - * ( item)[0] = value - */ - /*try:*/ { - - /* "View.MemoryView":471 - * - * try: - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * ( item)[0] = value - * else: - */ - if (__pyx_v_self->dtype_is_object) { - - /* "View.MemoryView":472 - * try: - * if self.dtype_is_object: - * ( item)[0] = value # <<<<<<<<<<<<<< - * else: - * self.assign_item_from_object( item, value) - */ - (((PyObject **)__pyx_v_item)[0]) = ((PyObject *)__pyx_v_value); - - /* "View.MemoryView":471 - * - * try: - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * ( item)[0] = value - * else: - */ - goto __pyx_L8; - } - - /* "View.MemoryView":474 - * ( item)[0] = value - * else: - * self.assign_item_from_object( item, value) # <<<<<<<<<<<<<< - * - * - */ - /*else*/ { - __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, ((char *)__pyx_v_item), __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 474, __pyx_L6_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } - __pyx_L8:; - - /* "View.MemoryView":478 - * - * - * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< - * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) - * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, - */ - __pyx_t_2 = (__pyx_v_self->view.suboffsets != NULL); - if (__pyx_t_2) { - - /* "View.MemoryView":479 - * - * if self.view.suboffsets != NULL: - * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) # <<<<<<<<<<<<<< - * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, - * item, self.dtype_is_object) - */ - __pyx_t_4 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 479, __pyx_L6_error) - - /* "View.MemoryView":478 - * - * - * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< - * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) - * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, - */ - } - - /* "View.MemoryView":480 - * if self.view.suboffsets != NULL: - * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) - * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, # <<<<<<<<<<<<<< - * item, self.dtype_is_object) - * finally: - */ - __pyx_memoryview_slice_assign_scalar(__pyx_v_dst_slice, __pyx_v_dst->view.ndim, __pyx_v_self->view.itemsize, __pyx_v_item, __pyx_v_self->dtype_is_object); - } - - /* "View.MemoryView":483 - * item, self.dtype_is_object) - * finally: - * PyMem_Free(tmp) # <<<<<<<<<<<<<< - * - * cdef setitem_indexed(self, index, value): - */ - /*finally:*/ { - /*normal exit:*/{ - PyMem_Free(__pyx_v_tmp); - goto __pyx_L7; - } - __pyx_L6_error:; - /*exception exit:*/{ - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); - if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); - __Pyx_XGOTREF(__pyx_t_7); - __Pyx_XGOTREF(__pyx_t_8); - __Pyx_XGOTREF(__pyx_t_9); - __Pyx_XGOTREF(__pyx_t_10); - __Pyx_XGOTREF(__pyx_t_11); - __Pyx_XGOTREF(__pyx_t_12); - __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename; - { - PyMem_Free(__pyx_v_tmp); - } - if (PY_MAJOR_VERSION >= 3) { - __Pyx_XGIVEREF(__pyx_t_10); - __Pyx_XGIVEREF(__pyx_t_11); - __Pyx_XGIVEREF(__pyx_t_12); - __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); - } - __Pyx_XGIVEREF(__pyx_t_7); - __Pyx_XGIVEREF(__pyx_t_8); - __Pyx_XGIVEREF(__pyx_t_9); - __Pyx_ErrRestore(__pyx_t_7, __pyx_t_8, __pyx_t_9); - __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; - __pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_5; __pyx_filename = __pyx_t_6; - goto __pyx_L1_error; - } - __pyx_L7:; - } - - /* "View.MemoryView":453 - * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) - * - * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< - * cdef int array[128] - * cdef void *tmp = NULL - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assign_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":485 - * PyMem_Free(tmp) - * - * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< - * cdef char *itemp = self.get_item_pointer(index) - * self.assign_item_from_object(itemp, value) - */ - -static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { - char *__pyx_v_itemp; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - char *__pyx_t_1; - PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("setitem_indexed", 0); - - /* "View.MemoryView":486 - * - * cdef setitem_indexed(self, index, value): - * cdef char *itemp = self.get_item_pointer(index) # <<<<<<<<<<<<<< - * self.assign_item_from_object(itemp, value) - * - */ - __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_index); if (unlikely(__pyx_t_1 == ((char *)NULL))) __PYX_ERR(1, 486, __pyx_L1_error) - __pyx_v_itemp = __pyx_t_1; - - /* "View.MemoryView":487 - * cdef setitem_indexed(self, index, value): - * cdef char *itemp = self.get_item_pointer(index) - * self.assign_item_from_object(itemp, value) # <<<<<<<<<<<<<< - * - * cdef convert_item_to_object(self, char *itemp): - */ - __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 487, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "View.MemoryView":485 - * PyMem_Free(tmp) - * - * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< - * cdef char *itemp = self.get_item_pointer(index) - * self.assign_item_from_object(itemp, value) - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_indexed", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":489 - * self.assign_item_from_object(itemp, value) - * - * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< - * """Only used if instantiated manually by the user, or if Cython doesn't - * know how to convert the type""" - */ - -static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp) { - PyObject *__pyx_v_struct = NULL; - PyObject *__pyx_v_bytesitem = 0; - PyObject *__pyx_v_result = NULL; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - int __pyx_t_8; - Py_ssize_t __pyx_t_9; - int __pyx_t_10; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("convert_item_to_object", 0); - - /* "View.MemoryView":492 - * """Only used if instantiated manually by the user, or if Cython doesn't - * know how to convert the type""" - * import struct # <<<<<<<<<<<<<< - * cdef bytes bytesitem - * - */ - __pyx_t_1 = __Pyx_ImportDottedModule(__pyx_n_s_struct, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 492, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_struct = __pyx_t_1; - __pyx_t_1 = 0; - - /* "View.MemoryView":495 - * cdef bytes bytesitem - * - * bytesitem = itemp[:self.view.itemsize] # <<<<<<<<<<<<<< - * try: - * result = struct.unpack(self.view.format, bytesitem) - */ - __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_itemp + 0, __pyx_v_self->view.itemsize - 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_bytesitem = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - /* "View.MemoryView":496 - * - * bytesitem = itemp[:self.view.itemsize] - * try: # <<<<<<<<<<<<<< - * result = struct.unpack(self.view.format, bytesitem) - * except struct.error: - */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); - __Pyx_XGOTREF(__pyx_t_2); - __Pyx_XGOTREF(__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_4); - /*try:*/ { - - /* "View.MemoryView":497 - * bytesitem = itemp[:self.view.itemsize] - * try: - * result = struct.unpack(self.view.format, bytesitem) # <<<<<<<<<<<<<< - * except struct.error: - * raise ValueError, "Unable to convert item to object" - */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_unpack); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 497, __pyx_L3_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 497, __pyx_L3_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = NULL; - __pyx_t_8 = 0; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_8 = 1; - } - } - { - PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_8, 2+__pyx_t_8); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 497, __pyx_L3_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } - __pyx_v_result = __pyx_t_1; - __pyx_t_1 = 0; - - /* "View.MemoryView":496 - * - * bytesitem = itemp[:self.view.itemsize] - * try: # <<<<<<<<<<<<<< - * result = struct.unpack(self.view.format, bytesitem) - * except struct.error: - */ - } - - /* "View.MemoryView":501 - * raise ValueError, "Unable to convert item to object" - * else: - * if len(self.view.format) == 1: # <<<<<<<<<<<<<< - * return result[0] - * return result - */ - /*else:*/ { - __pyx_t_9 = __Pyx_ssize_strlen(__pyx_v_self->view.format); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(1, 501, __pyx_L5_except_error) - __pyx_t_10 = (__pyx_t_9 == 1); - if (__pyx_t_10) { - - /* "View.MemoryView":502 - * else: - * if len(self.view.format) == 1: - * return result[0] # <<<<<<<<<<<<<< - * return result - * - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_result, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 502, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L6_except_return; - - /* "View.MemoryView":501 - * raise ValueError, "Unable to convert item to object" - * else: - * if len(self.view.format) == 1: # <<<<<<<<<<<<<< - * return result[0] - * return result - */ - } - - /* "View.MemoryView":503 - * if len(self.view.format) == 1: - * return result[0] - * return result # <<<<<<<<<<<<<< - * - * cdef assign_item_from_object(self, char *itemp, object value): - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_result); - __pyx_r = __pyx_v_result; - goto __pyx_L6_except_return; - } - __pyx_L3_error:; - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "View.MemoryView":498 - * try: - * result = struct.unpack(self.view.format, bytesitem) - * except struct.error: # <<<<<<<<<<<<<< - * raise ValueError, "Unable to convert item to object" - * else: - */ - __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_5, &__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 498, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_7); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_ErrRestore(__pyx_t_1, __pyx_t_5, __pyx_t_6); - __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_6 = 0; - if (__pyx_t_8) { - __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(1, 498, __pyx_L5_except_error) - __Pyx_XGOTREF(__pyx_t_6); - __Pyx_XGOTREF(__pyx_t_5); - __Pyx_XGOTREF(__pyx_t_1); - - /* "View.MemoryView":499 - * result = struct.unpack(self.view.format, bytesitem) - * except struct.error: - * raise ValueError, "Unable to convert item to object" # <<<<<<<<<<<<<< - * else: - * if len(self.view.format) == 1: - */ - __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Unable_to_convert_item_to_object, 0, 0); - __PYX_ERR(1, 499, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - - /* "View.MemoryView":496 - * - * bytesitem = itemp[:self.view.itemsize] - * try: # <<<<<<<<<<<<<< - * result = struct.unpack(self.view.format, bytesitem) - * except struct.error: - */ - __pyx_L5_except_error:; - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_XGIVEREF(__pyx_t_4); - __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); - goto __pyx_L1_error; - __pyx_L6_except_return:; - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_XGIVEREF(__pyx_t_4); - __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); - goto __pyx_L0; - } - - /* "View.MemoryView":489 - * self.assign_item_from_object(itemp, value) - * - * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< - * """Only used if instantiated manually by the user, or if Cython doesn't - * know how to convert the type""" - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_struct); - __Pyx_XDECREF(__pyx_v_bytesitem); - __Pyx_XDECREF(__pyx_v_result); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":505 - * return result - * - * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< - * """Only used if instantiated manually by the user, or if Cython doesn't - * know how to convert the type""" - */ - -static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { - PyObject *__pyx_v_struct = NULL; - char __pyx_v_c; - PyObject *__pyx_v_bytesvalue = 0; - Py_ssize_t __pyx_v_i; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; - Py_ssize_t __pyx_t_7; - PyObject *__pyx_t_8 = NULL; - char *__pyx_t_9; - char *__pyx_t_10; - char *__pyx_t_11; - char *__pyx_t_12; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("assign_item_from_object", 0); - - /* "View.MemoryView":508 - * """Only used if instantiated manually by the user, or if Cython doesn't - * know how to convert the type""" - * import struct # <<<<<<<<<<<<<< - * cdef char c - * cdef bytes bytesvalue - */ - __pyx_t_1 = __Pyx_ImportDottedModule(__pyx_n_s_struct, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 508, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_struct = __pyx_t_1; - __pyx_t_1 = 0; - - /* "View.MemoryView":513 - * cdef Py_ssize_t i - * - * if isinstance(value, tuple): # <<<<<<<<<<<<<< - * bytesvalue = struct.pack(self.view.format, *value) - * else: - */ - __pyx_t_2 = PyTuple_Check(__pyx_v_value); - if (__pyx_t_2) { - - /* "View.MemoryView":514 - * - * if isinstance(value, tuple): - * bytesvalue = struct.pack(self.view.format, *value) # <<<<<<<<<<<<<< - * else: - * bytesvalue = struct.pack(self.view.format, value) - */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 514, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = PyNumber_Add(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 514, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (!(likely(PyBytes_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_3))) __PYX_ERR(1, 514, __pyx_L1_error) - __pyx_v_bytesvalue = ((PyObject*)__pyx_t_3); - __pyx_t_3 = 0; - - /* "View.MemoryView":513 - * cdef Py_ssize_t i - * - * if isinstance(value, tuple): # <<<<<<<<<<<<<< - * bytesvalue = struct.pack(self.view.format, *value) - * else: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":516 - * bytesvalue = struct.pack(self.view.format, *value) - * else: - * bytesvalue = struct.pack(self.view.format, value) # <<<<<<<<<<<<<< - * - * for i, c in enumerate(bytesvalue): - */ - /*else*/ { - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 516, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 516, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = NULL; - __pyx_t_6 = 0; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_6 = 1; - } - } - { - PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_v_value}; - __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 516, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } - if (!(likely(PyBytes_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_3))) __PYX_ERR(1, 516, __pyx_L1_error) - __pyx_v_bytesvalue = ((PyObject*)__pyx_t_3); - __pyx_t_3 = 0; - } - __pyx_L3:; - - /* "View.MemoryView":518 - * bytesvalue = struct.pack(self.view.format, value) - * - * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< - * itemp[i] = c - * - */ - __pyx_t_7 = 0; - if (unlikely(__pyx_v_bytesvalue == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable"); - __PYX_ERR(1, 518, __pyx_L1_error) - } - __Pyx_INCREF(__pyx_v_bytesvalue); - __pyx_t_8 = __pyx_v_bytesvalue; - __pyx_t_10 = PyBytes_AS_STRING(__pyx_t_8); - __pyx_t_11 = (__pyx_t_10 + PyBytes_GET_SIZE(__pyx_t_8)); - for (__pyx_t_12 = __pyx_t_10; __pyx_t_12 < __pyx_t_11; __pyx_t_12++) { - __pyx_t_9 = __pyx_t_12; - __pyx_v_c = (__pyx_t_9[0]); - - /* "View.MemoryView":519 - * - * for i, c in enumerate(bytesvalue): - * itemp[i] = c # <<<<<<<<<<<<<< - * - * @cname('getbuffer') - */ - __pyx_v_i = __pyx_t_7; - - /* "View.MemoryView":518 - * bytesvalue = struct.pack(self.view.format, value) - * - * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< - * itemp[i] = c - * - */ - __pyx_t_7 = (__pyx_t_7 + 1); - - /* "View.MemoryView":519 - * - * for i, c in enumerate(bytesvalue): - * itemp[i] = c # <<<<<<<<<<<<<< - * - * @cname('getbuffer') - */ - (__pyx_v_itemp[__pyx_v_i]) = __pyx_v_c; - } - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - - /* "View.MemoryView":505 - * return result - * - * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< - * """Only used if instantiated manually by the user, or if Cython doesn't - * know how to convert the type""" - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("View.MemoryView.memoryview.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_struct); - __Pyx_XDECREF(__pyx_v_bytesvalue); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":521 - * itemp[i] = c - * - * @cname('getbuffer') # <<<<<<<<<<<<<< - * def __getbuffer__(self, Py_buffer *info, int flags): - * if flags & PyBUF_WRITABLE and self.view.readonly: - */ - -/* Python wrapper */ -CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ -CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - int __pyx_r; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - Py_ssize_t *__pyx_t_3; - char *__pyx_t_4; - void *__pyx_t_5; - int __pyx_t_6; - Py_ssize_t __pyx_t_7; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - if (unlikely(__pyx_v_info == NULL)) { - PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); - return -1; - } - __Pyx_RefNannySetupContext("__getbuffer__", 0); - __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(__pyx_v_info->obj); - - /* "View.MemoryView":523 - * @cname('getbuffer') - * def __getbuffer__(self, Py_buffer *info, int flags): - * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< - * raise ValueError, "Cannot create writable memory view from read-only memoryview" - * - */ - __pyx_t_2 = ((__pyx_v_flags & PyBUF_WRITABLE) != 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_1 = __pyx_v_self->view.readonly; - __pyx_L4_bool_binop_done:; - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":524 - * def __getbuffer__(self, Py_buffer *info, int flags): - * if flags & PyBUF_WRITABLE and self.view.readonly: - * raise ValueError, "Cannot create writable memory view from read-only memoryview" # <<<<<<<<<<<<<< - * - * if flags & PyBUF_ND: - */ - __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Cannot_create_writable_memory_vi, 0, 0); - __PYX_ERR(1, 524, __pyx_L1_error) - - /* "View.MemoryView":523 - * @cname('getbuffer') - * def __getbuffer__(self, Py_buffer *info, int flags): - * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< - * raise ValueError, "Cannot create writable memory view from read-only memoryview" - * - */ - } - - /* "View.MemoryView":526 - * raise ValueError, "Cannot create writable memory view from read-only memoryview" - * - * if flags & PyBUF_ND: # <<<<<<<<<<<<<< - * info.shape = self.view.shape - * else: - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":527 - * - * if flags & PyBUF_ND: - * info.shape = self.view.shape # <<<<<<<<<<<<<< - * else: - * info.shape = NULL - */ - __pyx_t_3 = __pyx_v_self->view.shape; - __pyx_v_info->shape = __pyx_t_3; - - /* "View.MemoryView":526 - * raise ValueError, "Cannot create writable memory view from read-only memoryview" - * - * if flags & PyBUF_ND: # <<<<<<<<<<<<<< - * info.shape = self.view.shape - * else: - */ - goto __pyx_L6; - } - - /* "View.MemoryView":529 - * info.shape = self.view.shape - * else: - * info.shape = NULL # <<<<<<<<<<<<<< - * - * if flags & PyBUF_STRIDES: - */ - /*else*/ { - __pyx_v_info->shape = NULL; - } - __pyx_L6:; - - /* "View.MemoryView":531 - * info.shape = NULL - * - * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< - * info.strides = self.view.strides - * else: - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":532 - * - * if flags & PyBUF_STRIDES: - * info.strides = self.view.strides # <<<<<<<<<<<<<< - * else: - * info.strides = NULL - */ - __pyx_t_3 = __pyx_v_self->view.strides; - __pyx_v_info->strides = __pyx_t_3; - - /* "View.MemoryView":531 - * info.shape = NULL - * - * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< - * info.strides = self.view.strides - * else: - */ - goto __pyx_L7; - } - - /* "View.MemoryView":534 - * info.strides = self.view.strides - * else: - * info.strides = NULL # <<<<<<<<<<<<<< - * - * if flags & PyBUF_INDIRECT: - */ - /*else*/ { - __pyx_v_info->strides = NULL; - } - __pyx_L7:; - - /* "View.MemoryView":536 - * info.strides = NULL - * - * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< - * info.suboffsets = self.view.suboffsets - * else: - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_INDIRECT) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":537 - * - * if flags & PyBUF_INDIRECT: - * info.suboffsets = self.view.suboffsets # <<<<<<<<<<<<<< - * else: - * info.suboffsets = NULL - */ - __pyx_t_3 = __pyx_v_self->view.suboffsets; - __pyx_v_info->suboffsets = __pyx_t_3; - - /* "View.MemoryView":536 - * info.strides = NULL - * - * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< - * info.suboffsets = self.view.suboffsets - * else: - */ - goto __pyx_L8; - } - - /* "View.MemoryView":539 - * info.suboffsets = self.view.suboffsets - * else: - * info.suboffsets = NULL # <<<<<<<<<<<<<< - * - * if flags & PyBUF_FORMAT: - */ - /*else*/ { - __pyx_v_info->suboffsets = NULL; - } - __pyx_L8:; - - /* "View.MemoryView":541 - * info.suboffsets = NULL - * - * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< - * info.format = self.view.format - * else: - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":542 - * - * if flags & PyBUF_FORMAT: - * info.format = self.view.format # <<<<<<<<<<<<<< - * else: - * info.format = NULL - */ - __pyx_t_4 = __pyx_v_self->view.format; - __pyx_v_info->format = __pyx_t_4; - - /* "View.MemoryView":541 - * info.suboffsets = NULL - * - * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< - * info.format = self.view.format - * else: - */ - goto __pyx_L9; - } - - /* "View.MemoryView":544 - * info.format = self.view.format - * else: - * info.format = NULL # <<<<<<<<<<<<<< - * - * info.buf = self.view.buf - */ - /*else*/ { - __pyx_v_info->format = NULL; - } - __pyx_L9:; - - /* "View.MemoryView":546 - * info.format = NULL - * - * info.buf = self.view.buf # <<<<<<<<<<<<<< - * info.ndim = self.view.ndim - * info.itemsize = self.view.itemsize - */ - __pyx_t_5 = __pyx_v_self->view.buf; - __pyx_v_info->buf = __pyx_t_5; - - /* "View.MemoryView":547 - * - * info.buf = self.view.buf - * info.ndim = self.view.ndim # <<<<<<<<<<<<<< - * info.itemsize = self.view.itemsize - * info.len = self.view.len - */ - __pyx_t_6 = __pyx_v_self->view.ndim; - __pyx_v_info->ndim = __pyx_t_6; - - /* "View.MemoryView":548 - * info.buf = self.view.buf - * info.ndim = self.view.ndim - * info.itemsize = self.view.itemsize # <<<<<<<<<<<<<< - * info.len = self.view.len - * info.readonly = self.view.readonly - */ - __pyx_t_7 = __pyx_v_self->view.itemsize; - __pyx_v_info->itemsize = __pyx_t_7; - - /* "View.MemoryView":549 - * info.ndim = self.view.ndim - * info.itemsize = self.view.itemsize - * info.len = self.view.len # <<<<<<<<<<<<<< - * info.readonly = self.view.readonly - * info.obj = self - */ - __pyx_t_7 = __pyx_v_self->view.len; - __pyx_v_info->len = __pyx_t_7; - - /* "View.MemoryView":550 - * info.itemsize = self.view.itemsize - * info.len = self.view.len - * info.readonly = self.view.readonly # <<<<<<<<<<<<<< - * info.obj = self - * - */ - __pyx_t_1 = __pyx_v_self->view.readonly; - __pyx_v_info->readonly = __pyx_t_1; - - /* "View.MemoryView":551 - * info.len = self.view.len - * info.readonly = self.view.readonly - * info.obj = self # <<<<<<<<<<<<<< - * - * - */ - __Pyx_INCREF((PyObject *)__pyx_v_self); - __Pyx_GIVEREF((PyObject *)__pyx_v_self); - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); - __pyx_v_info->obj = ((PyObject *)__pyx_v_self); - - /* "View.MemoryView":521 - * itemp[i] = c - * - * @cname('getbuffer') # <<<<<<<<<<<<<< - * def __getbuffer__(self, Py_buffer *info, int flags): - * if flags & PyBUF_WRITABLE and self.view.readonly: - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_AddTraceback("View.MemoryView.memoryview.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - if (__pyx_v_info->obj != NULL) { - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; - } - goto __pyx_L2; - __pyx_L0:; - if (__pyx_v_info->obj == Py_None) { - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; - } - __pyx_L2:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":554 - * - * - * @property # <<<<<<<<<<<<<< - * def T(self): - * cdef _memoryviewslice result = memoryview_copy(self) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); - - /* "View.MemoryView":556 - * @property - * def T(self): - * cdef _memoryviewslice result = memoryview_copy(self) # <<<<<<<<<<<<<< - * transpose_memslice(&result.from_slice) - * return result - */ - __pyx_t_1 = __pyx_memoryview_copy_object(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 556, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_memoryviewslice_type))))) __PYX_ERR(1, 556, __pyx_L1_error) - __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_1); - __pyx_t_1 = 0; - - /* "View.MemoryView":557 - * def T(self): - * cdef _memoryviewslice result = memoryview_copy(self) - * transpose_memslice(&result.from_slice) # <<<<<<<<<<<<<< - * return result - * - */ - __pyx_t_2 = __pyx_memslice_transpose((&__pyx_v_result->from_slice)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 557, __pyx_L1_error) - - /* "View.MemoryView":558 - * cdef _memoryviewslice result = memoryview_copy(self) - * transpose_memslice(&result.from_slice) - * return result # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF((PyObject *)__pyx_v_result); - __pyx_r = ((PyObject *)__pyx_v_result); - goto __pyx_L0; - - /* "View.MemoryView":554 - * - * - * @property # <<<<<<<<<<<<<< - * def T(self): - * cdef _memoryviewslice result = memoryview_copy(self) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.memoryview.T.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_result); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":560 - * return result - * - * @property # <<<<<<<<<<<<<< - * def base(self): - * return self._get_base() - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); - - /* "View.MemoryView":562 - * @property - * def base(self): - * return self._get_base() # <<<<<<<<<<<<<< - * - * cdef _get_base(self): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->_get_base(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 562, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "View.MemoryView":560 - * return result - * - * @property # <<<<<<<<<<<<<< - * def base(self): - * return self._get_base() - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.memoryview.base.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":564 - * return self._get_base() - * - * cdef _get_base(self): # <<<<<<<<<<<<<< - * return self.obj - * - */ - -static PyObject *__pyx_memoryview__get_base(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("_get_base", 0); - - /* "View.MemoryView":565 - * - * cdef _get_base(self): - * return self.obj # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->obj); - __pyx_r = __pyx_v_self->obj; - goto __pyx_L0; - - /* "View.MemoryView":564 - * return self._get_base() - * - * cdef _get_base(self): # <<<<<<<<<<<<<< - * return self.obj - * - */ - - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":567 - * return self.obj - * - * @property # <<<<<<<<<<<<<< - * def shape(self): - * return tuple([length for length in self.view.shape[:self.view.ndim]]) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - Py_ssize_t __pyx_7genexpr__pyx_v_length; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - Py_ssize_t *__pyx_t_2; - Py_ssize_t *__pyx_t_3; - Py_ssize_t *__pyx_t_4; - PyObject *__pyx_t_5 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); - - /* "View.MemoryView":569 - * @property - * def shape(self): - * return tuple([length for length in self.view.shape[:self.view.ndim]]) # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - { /* enter inner scope */ - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 569, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); - for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { - __pyx_t_2 = __pyx_t_4; - __pyx_7genexpr__pyx_v_length = (__pyx_t_2[0]); - __pyx_t_5 = PyInt_FromSsize_t(__pyx_7genexpr__pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 569, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 569, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } - } /* exit inner scope */ - __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 569, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; - goto __pyx_L0; - - /* "View.MemoryView":567 - * return self.obj - * - * @property # <<<<<<<<<<<<<< - * def shape(self): - * return tuple([length for length in self.view.shape[:self.view.ndim]]) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("View.MemoryView.memoryview.shape.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":571 - * return tuple([length for length in self.view.shape[:self.view.ndim]]) - * - * @property # <<<<<<<<<<<<<< - * def strides(self): - * if self.view.strides == NULL: - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - Py_ssize_t __pyx_8genexpr1__pyx_v_stride; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - Py_ssize_t *__pyx_t_3; - Py_ssize_t *__pyx_t_4; - Py_ssize_t *__pyx_t_5; - PyObject *__pyx_t_6 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); - - /* "View.MemoryView":573 - * @property - * def strides(self): - * if self.view.strides == NULL: # <<<<<<<<<<<<<< - * - * raise ValueError, "Buffer view does not expose strides" - */ - __pyx_t_1 = (__pyx_v_self->view.strides == NULL); - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":575 - * if self.view.strides == NULL: - * - * raise ValueError, "Buffer view does not expose strides" # <<<<<<<<<<<<<< - * - * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) - */ - __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Buffer_view_does_not_expose_stri, 0, 0); - __PYX_ERR(1, 575, __pyx_L1_error) - - /* "View.MemoryView":573 - * @property - * def strides(self): - * if self.view.strides == NULL: # <<<<<<<<<<<<<< - * - * raise ValueError, "Buffer view does not expose strides" - */ - } - - /* "View.MemoryView":577 - * raise ValueError, "Buffer view does not expose strides" - * - * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - { /* enter inner scope */ - __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 577, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = (__pyx_v_self->view.strides + __pyx_v_self->view.ndim); - for (__pyx_t_5 = __pyx_v_self->view.strides; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { - __pyx_t_3 = __pyx_t_5; - __pyx_8genexpr1__pyx_v_stride = (__pyx_t_3[0]); - __pyx_t_6 = PyInt_FromSsize_t(__pyx_8genexpr1__pyx_v_stride); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 577, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 577, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - } - } /* exit inner scope */ - __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 577, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_r = __pyx_t_6; - __pyx_t_6 = 0; - goto __pyx_L0; - - /* "View.MemoryView":571 - * return tuple([length for length in self.view.shape[:self.view.ndim]]) - * - * @property # <<<<<<<<<<<<<< - * def strides(self): - * if self.view.strides == NULL: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("View.MemoryView.memoryview.strides.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":579 - * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) - * - * @property # <<<<<<<<<<<<<< - * def suboffsets(self): - * if self.view.suboffsets == NULL: - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - Py_ssize_t __pyx_8genexpr2__pyx_v_suboffset; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - Py_ssize_t *__pyx_t_3; - Py_ssize_t *__pyx_t_4; - Py_ssize_t *__pyx_t_5; - PyObject *__pyx_t_6 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); - - /* "View.MemoryView":581 - * @property - * def suboffsets(self): - * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< - * return (-1,) * self.view.ndim - * - */ - __pyx_t_1 = (__pyx_v_self->view.suboffsets == NULL); - if (__pyx_t_1) { - - /* "View.MemoryView":582 - * def suboffsets(self): - * if self.view.suboffsets == NULL: - * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< - * - * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PySequence_Multiply(__pyx_tuple__4, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 582, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":581 - * @property - * def suboffsets(self): - * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< - * return (-1,) * self.view.ndim - * - */ - } - - /* "View.MemoryView":584 - * return (-1,) * self.view.ndim - * - * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - { /* enter inner scope */ - __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 584, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = (__pyx_v_self->view.suboffsets + __pyx_v_self->view.ndim); - for (__pyx_t_5 = __pyx_v_self->view.suboffsets; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { - __pyx_t_3 = __pyx_t_5; - __pyx_8genexpr2__pyx_v_suboffset = (__pyx_t_3[0]); - __pyx_t_6 = PyInt_FromSsize_t(__pyx_8genexpr2__pyx_v_suboffset); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 584, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 584, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - } - } /* exit inner scope */ - __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 584, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_r = __pyx_t_6; - __pyx_t_6 = 0; - goto __pyx_L0; - - /* "View.MemoryView":579 - * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) - * - * @property # <<<<<<<<<<<<<< - * def suboffsets(self): - * if self.view.suboffsets == NULL: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("View.MemoryView.memoryview.suboffsets.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":586 - * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) - * - * @property # <<<<<<<<<<<<<< - * def ndim(self): - * return self.view.ndim - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); - - /* "View.MemoryView":588 - * @property - * def ndim(self): - * return self.view.ndim # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 588, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "View.MemoryView":586 - * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) - * - * @property # <<<<<<<<<<<<<< - * def ndim(self): - * return self.view.ndim - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.memoryview.ndim.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":590 - * return self.view.ndim - * - * @property # <<<<<<<<<<<<<< - * def itemsize(self): - * return self.view.itemsize - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); - - /* "View.MemoryView":592 - * @property - * def itemsize(self): - * return self.view.itemsize # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 592, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "View.MemoryView":590 - * return self.view.ndim - * - * @property # <<<<<<<<<<<<<< - * def itemsize(self): - * return self.view.itemsize - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.memoryview.itemsize.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":594 - * return self.view.itemsize - * - * @property # <<<<<<<<<<<<<< - * def nbytes(self): - * return self.size * self.view.itemsize - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); - - /* "View.MemoryView":596 - * @property - * def nbytes(self): - * return self.size * self.view.itemsize # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 596, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 596, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 596, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L0; - - /* "View.MemoryView":594 - * return self.view.itemsize - * - * @property # <<<<<<<<<<<<<< - * def nbytes(self): - * return self.size * self.view.itemsize - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.memoryview.nbytes.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":598 - * return self.size * self.view.itemsize - * - * @property # <<<<<<<<<<<<<< - * def size(self): - * if self._size is None: - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_v_result = NULL; - PyObject *__pyx_v_length = NULL; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - Py_ssize_t *__pyx_t_2; - Py_ssize_t *__pyx_t_3; - Py_ssize_t *__pyx_t_4; - PyObject *__pyx_t_5 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); - - /* "View.MemoryView":600 - * @property - * def size(self): - * if self._size is None: # <<<<<<<<<<<<<< - * result = 1 - * - */ - __pyx_t_1 = (__pyx_v_self->_size == Py_None); - if (__pyx_t_1) { - - /* "View.MemoryView":601 - * def size(self): - * if self._size is None: - * result = 1 # <<<<<<<<<<<<<< - * - * for length in self.view.shape[:self.view.ndim]: - */ - __Pyx_INCREF(__pyx_int_1); - __pyx_v_result = __pyx_int_1; - - /* "View.MemoryView":603 - * result = 1 - * - * for length in self.view.shape[:self.view.ndim]: # <<<<<<<<<<<<<< - * result *= length - * - */ - __pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); - for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { - __pyx_t_2 = __pyx_t_4; - __pyx_t_5 = PyInt_FromSsize_t((__pyx_t_2[0])); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 603, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_5); - __pyx_t_5 = 0; - - /* "View.MemoryView":604 - * - * for length in self.view.shape[:self.view.ndim]: - * result *= length # <<<<<<<<<<<<<< - * - * self._size = result - */ - __pyx_t_5 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 604, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_5); - __pyx_t_5 = 0; - } - - /* "View.MemoryView":606 - * result *= length - * - * self._size = result # <<<<<<<<<<<<<< - * - * return self._size - */ - __Pyx_INCREF(__pyx_v_result); - __Pyx_GIVEREF(__pyx_v_result); - __Pyx_GOTREF(__pyx_v_self->_size); - __Pyx_DECREF(__pyx_v_self->_size); - __pyx_v_self->_size = __pyx_v_result; - - /* "View.MemoryView":600 - * @property - * def size(self): - * if self._size is None: # <<<<<<<<<<<<<< - * result = 1 - * - */ - } - - /* "View.MemoryView":608 - * self._size = result - * - * return self._size # <<<<<<<<<<<<<< - * - * def __len__(self): - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->_size); - __pyx_r = __pyx_v_self->_size; - goto __pyx_L0; - - /* "View.MemoryView":598 - * return self.size * self.view.itemsize - * - * @property # <<<<<<<<<<<<<< - * def size(self): - * if self._size is None: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("View.MemoryView.memoryview.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_result); - __Pyx_XDECREF(__pyx_v_length); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":610 - * return self._size - * - * def __len__(self): # <<<<<<<<<<<<<< - * if self.view.ndim >= 1: - * return self.view.shape[0] - */ - -/* Python wrapper */ -static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self); /*proto*/ -static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - Py_ssize_t __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self) { - Py_ssize_t __pyx_r; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - __Pyx_RefNannySetupContext("__len__", 0); - - /* "View.MemoryView":611 - * - * def __len__(self): - * if self.view.ndim >= 1: # <<<<<<<<<<<<<< - * return self.view.shape[0] - * - */ - __pyx_t_1 = (__pyx_v_self->view.ndim >= 1); - if (__pyx_t_1) { - - /* "View.MemoryView":612 - * def __len__(self): - * if self.view.ndim >= 1: - * return self.view.shape[0] # <<<<<<<<<<<<<< - * - * return 0 - */ - __pyx_r = (__pyx_v_self->view.shape[0]); - goto __pyx_L0; - - /* "View.MemoryView":611 - * - * def __len__(self): - * if self.view.ndim >= 1: # <<<<<<<<<<<<<< - * return self.view.shape[0] - * - */ - } - - /* "View.MemoryView":614 - * return self.view.shape[0] - * - * return 0 # <<<<<<<<<<<<<< - * - * def __repr__(self): - */ - __pyx_r = 0; - goto __pyx_L0; - - /* "View.MemoryView":610 - * return self._size - * - * def __len__(self): # <<<<<<<<<<<<<< - * if self.view.ndim >= 1: - * return self.view.shape[0] - */ - - /* function exit code */ - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":616 - * return 0 - * - * def __repr__(self): # <<<<<<<<<<<<<< - * return " " % (self.base.__class__.__name__, - * id(self)) - */ - -/* Python wrapper */ -static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__repr__", 0); - - /* "View.MemoryView":617 - * - * def __repr__(self): - * return " " % (self.base.__class__.__name__, # <<<<<<<<<<<<<< - * id(self)) - * - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 617, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 617, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 617, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "View.MemoryView":618 - * def __repr__(self): - * return " " % (self.base.__class__.__name__, - * id(self)) # <<<<<<<<<<<<<< - * - * def __str__(self): - */ - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 618, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - - /* "View.MemoryView":617 - * - * def __repr__(self): - * return " " % (self.base.__class__.__name__, # <<<<<<<<<<<<<< - * id(self)) - * - */ - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 617, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); - __pyx_t_1 = 0; - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 617, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":616 - * return 0 - * - * def __repr__(self): # <<<<<<<<<<<<<< - * return " " % (self.base.__class__.__name__, - * id(self)) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.memoryview.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":620 - * id(self)) - * - * def __str__(self): # <<<<<<<<<<<<<< - * return "