index
int64 0
731k
| package
stringlengths 2
98
⌀ | name
stringlengths 1
76
| docstring
stringlengths 0
281k
⌀ | code
stringlengths 4
1.07M
⌀ | signature
stringlengths 2
42.8k
⌀ |
|---|---|---|---|---|---|
21,635 | auto_gptq.modeling.auto | AutoGPTQForCausalLM | null | class AutoGPTQForCausalLM:
def __init__(self):
raise EnvironmentError(
"AutoGPTQModelForCausalLM is designed to be instantiated\n"
"using `AutoGPTQModelForCausalLM.from_pretrained` if want to quantize a pretrained model.\n"
"using `AutoGPTQModelForCausalLM.from_quantized` if want to inference with quantized model."
)
@classmethod
def from_pretrained(
cls,
pretrained_model_name_or_path: str,
quantize_config: BaseQuantizeConfig,
max_memory: Optional[dict] = None,
trust_remote_code: bool = False,
**model_init_kwargs,
) -> BaseGPTQForCausalLM:
model_type = check_and_get_model_type(pretrained_model_name_or_path, trust_remote_code)
return GPTQ_CAUSAL_LM_MODEL_MAP[model_type].from_pretrained(
pretrained_model_name_or_path=pretrained_model_name_or_path,
quantize_config=quantize_config,
max_memory=max_memory,
trust_remote_code=trust_remote_code,
**model_init_kwargs,
)
@classmethod
def from_quantized(
cls,
model_name_or_path: Optional[str],
device_map: Optional[Union[str, Dict[str, Union[str, int]]]] = None,
max_memory: Optional[dict] = None,
device: Optional[Union[str, int]] = None,
low_cpu_mem_usage: bool = False,
use_triton: bool = False,
inject_fused_attention: bool = False,
inject_fused_mlp: bool = False,
use_cuda_fp16: bool = True,
quantize_config: Optional[BaseQuantizeConfig] = None,
model_basename: Optional[str] = None,
use_safetensors: bool = True,
trust_remote_code: bool = False,
warmup_triton: bool = False,
trainable: bool = False,
disable_exllama: Optional[bool] = None,
disable_exllamav2: bool = False,
use_marlin: bool = False,
**kwargs,
) -> BaseGPTQForCausalLM:
# If disable_exllamav2 is True, we want to fall back on the exllama kernel and not the cuda/cuda_old ones.
if disable_exllama is None:
if disable_exllamav2:
disable_exllama = False
else:
disable_exllama = True
model_type = check_and_get_model_type(model_name_or_path, trust_remote_code)
quant_func = GPTQ_CAUSAL_LM_MODEL_MAP[model_type].from_quantized
# A static list of kwargs needed for huggingface_hub
huggingface_kwargs = [
"cache_dir",
"force_download",
"proxies",
"resume_download",
"local_files_only",
"use_auth_token",
"revision",
"subfolder",
"_raise_exceptions_for_missing_entries",
"_commit_hash",
]
# TODO: do we need this filtering of kwargs? @PanQiWei is there a reason we can't just pass all kwargs?
keywords = {
key: kwargs[key]
for key in list(signature(quant_func).parameters.keys()) + huggingface_kwargs
if key in kwargs
}
return quant_func(
model_name_or_path=model_name_or_path,
device_map=device_map,
max_memory=max_memory,
device=device,
low_cpu_mem_usage=low_cpu_mem_usage,
use_triton=use_triton,
inject_fused_attention=inject_fused_attention,
inject_fused_mlp=inject_fused_mlp,
use_cuda_fp16=use_cuda_fp16,
quantize_config=quantize_config,
model_basename=model_basename,
use_safetensors=use_safetensors,
trust_remote_code=trust_remote_code,
warmup_triton=warmup_triton,
trainable=trainable,
disable_exllama=disable_exllama,
disable_exllamav2=disable_exllamav2,
use_marlin=use_marlin,
**keywords,
)
| () |
21,636 | auto_gptq.modeling.auto | __init__ | null | def __init__(self):
raise EnvironmentError(
"AutoGPTQModelForCausalLM is designed to be instantiated\n"
"using `AutoGPTQModelForCausalLM.from_pretrained` if want to quantize a pretrained model.\n"
"using `AutoGPTQModelForCausalLM.from_quantized` if want to inference with quantized model."
)
| (self) |
21,637 | auto_gptq.modeling._base | BaseQuantizeConfig | BaseQuantizeConfig(bits: int = 4, group_size: int = -1, damp_percent: float = 0.01, desc_act: bool = True, static_groups: bool = False, sym: bool = True, true_sequential: bool = True, is_marlin_format: bool = False, model_name_or_path: Optional[str] = None, model_file_base_name: Optional[str] = None, awq_gemm_checkpoint: Optional[bool] = False) | class BaseQuantizeConfig(PushToHubMixin):
bits: int = field(default=4, metadata={"choices": [2, 3, 4, 8]})
group_size: int = field(default=-1)
damp_percent: float = field(default=0.01)
desc_act: bool = field(default=True)
static_groups: bool = field(default=False)
sym: bool = field(default=True)
true_sequential: bool = field(default=True)
is_marlin_format: bool = field(default=False)
model_name_or_path: Optional[str] = field(default=None)
model_file_base_name: Optional[str] = field(default=None)
awq_gemm_checkpoint: Optional[bool] = field(default=False)
def __post_init__(self):
fields_info = fields(self)
if self.bits not in fields_info[0].metadata["choices"]:
raise ValueError(f"only support quantize to {fields_info[0].metadata['choices']} bits.")
if self.group_size != -1 and self.group_size <= 0:
raise ValueError("unless equal to -1, group_size must greater then 0.")
if not (0 < self.damp_percent < 1):
raise ValueError("damp_percent must between 0 and 1.")
def save_pretrained(self, save_dir: str, **kwargs):
with open(join(save_dir, "quantize_config.json"), "w", encoding="utf-8") as f:
json.dump(self.to_dict(), f, indent=2)
@classmethod
def from_pretrained(cls, save_dir: str, **kwargs):
# Parameters related to loading from Hugging Face Hub
cache_dir = kwargs.pop("cache_dir", None)
force_download = kwargs.pop("force_download", False)
resume_download = kwargs.pop("resume_download", False)
proxies = kwargs.pop("proxies", None)
local_files_only = kwargs.pop("local_files_only", False)
use_auth_token = kwargs.pop("use_auth_token", None)
revision = kwargs.pop("revision", None)
subfolder = kwargs.pop("subfolder", None)
commit_hash = kwargs.pop("_commit_hash", None)
transformers_config = False
for quantize_config_filename in [
"quantize_config.json",
"quant_config.json",
"config.json",
]:
if os.path.isdir(save_dir): # Local
resolved_config_file = join(save_dir, quantize_config_filename)
else: # Remote
resolved_config_file = cached_file(
save_dir,
quantize_config_filename,
cache_dir=cache_dir,
force_download=force_download,
resume_download=resume_download,
proxies=proxies,
use_auth_token=use_auth_token,
revision=revision,
local_files_only=local_files_only,
subfolder=subfolder,
_raise_exceptions_for_missing_entries=False,
_raise_exceptions_for_connection_errors=False,
_commit_hash=commit_hash,
)
if resolved_config_file is not None:
if quantize_config_filename == "config.json":
transformers_config = True
break
if resolved_config_file is None:
raise ValueError(
"No quantize_config.json, quant_config.json or config.json file was found in the model repository."
)
field_names = [field.name for field in fields(cls)]
with open(resolved_config_file, "r", encoding="utf-8") as f:
args_from_json = json.load(f)
if transformers_config:
args_from_json = args_from_json["quantization_config"]
filtered_args = {"awq_gemm_checkpoint": False}
for key, val in args_from_json.items():
if key == "version" and val == "GEMM":
filtered_args["awq_gemm_checkpoint"] = True
elif key in field_names:
filtered_args[key] = val
elif key in SYNONYMS and SYNONYMS[key] in field_names:
filtered_args[SYNONYMS[key]] = val
else:
logger.warning(f"ignoring unknown parameter in {quantize_config_filename}: {key}.")
if filtered_args["awq_gemm_checkpoint"]:
# AWQ does not reorder the rows.
filtered_args["desc_act"] = False
if "sym" not in args_from_json:
logger.warning(
f"The quantization configuration {quantize_config_filename} does not contain an entry `sym` (symetric quantization). This may result in silent errors."
)
return cls(**filtered_args)
def to_dict(self):
return {
"bits": self.bits,
"group_size": self.group_size,
"damp_percent": self.damp_percent,
"desc_act": self.desc_act,
"static_groups": self.static_groups,
"sym": self.sym,
"true_sequential": self.true_sequential,
"model_name_or_path": self.model_name_or_path,
"model_file_base_name": self.model_file_base_name,
"is_marlin_format": self.is_marlin_format,
"quant_method": "gptq",
}
| (bits: int = 4, group_size: int = -1, damp_percent: float = 0.01, desc_act: bool = True, static_groups: bool = False, sym: bool = True, true_sequential: bool = True, is_marlin_format: bool = False, model_name_or_path: Optional[str] = None, model_file_base_name: Optional[str] = None, awq_gemm_checkpoint: Optional[bool] = False) -> None |
21,638 | auto_gptq.modeling._base | __eq__ | null | import copy
import json
import logging
import os
from dataclasses import dataclass, field, fields
from os.path import isdir, join
from typing import Dict, List, Optional, Union
import accelerate
import huggingface_hub
import torch
import torch.nn as nn
import transformers
from accelerate.hooks import remove_hook_from_module
from safetensors import safe_open
from safetensors.torch import load_file as safe_load
from safetensors.torch import save_file as safe_save
from tqdm import tqdm
from transformers import AutoConfig, AutoModelForCausalLM, PreTrainedModel
from transformers.modeling_utils import no_init_weights
from transformers.utils.generic import ContextManagers
from transformers.utils.hub import (
CommitOperationAdd,
PushToHubMixin,
cached_file,
create_commit,
create_repo,
)
from ..nn_modules._fused_base import FusedBaseAttentionModule, FusedBaseMLPModule
from ..nn_modules.qlinear import GeneralQuantLinear
from ..quantization import GPTQ
from ..utils.data_utils import collate_data
from ..utils.import_utils import (
AUTOGPTQ_CUDA_AVAILABLE,
EXLLAMA_KERNELS_AVAILABLE,
EXLLAMAV2_KERNELS_AVAILABLE,
MARLIN_AVAILABLE,
QIGEN_AVAILABLE,
TRITON_AVAILABLE,
dynamically_import_QuantLinear,
)
from ..utils.marlin_utils import (
_validate_marlin_compatibility,
_validate_marlin_device_support,
prepare_model_for_marlin_load,
)
from ._const import CPU, CUDA_0, SUPPORTED_MODELS
from ._utils import (
autogptq_post_init,
find_layers,
get_checkpoints,
get_device,
get_module_by_name_prefix,
get_module_by_name_suffix,
make_quant,
make_sure_no_tensor_in_meta_device,
move_to_device,
pack_from_tensors,
pack_model,
preprocess_checkpoint_qigen,
simple_dispatch_model,
unpack_awq,
)
logger = logging.getLogger(__name__)
handler = logging.StreamHandler()
formatter = logging.Formatter("%(levelname)s - %(message)s")
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(logging.INFO)
SYNONYMS = {
"w_bit": "bits",
"q_group_size": "group_size",
}
@dataclass
class BaseQuantizeConfig(PushToHubMixin):
bits: int = field(default=4, metadata={"choices": [2, 3, 4, 8]})
group_size: int = field(default=-1)
damp_percent: float = field(default=0.01)
desc_act: bool = field(default=True)
static_groups: bool = field(default=False)
sym: bool = field(default=True)
true_sequential: bool = field(default=True)
is_marlin_format: bool = field(default=False)
model_name_or_path: Optional[str] = field(default=None)
model_file_base_name: Optional[str] = field(default=None)
awq_gemm_checkpoint: Optional[bool] = field(default=False)
def __post_init__(self):
fields_info = fields(self)
if self.bits not in fields_info[0].metadata["choices"]:
raise ValueError(f"only support quantize to {fields_info[0].metadata['choices']} bits.")
if self.group_size != -1 and self.group_size <= 0:
raise ValueError("unless equal to -1, group_size must greater then 0.")
if not (0 < self.damp_percent < 1):
raise ValueError("damp_percent must between 0 and 1.")
def save_pretrained(self, save_dir: str, **kwargs):
with open(join(save_dir, "quantize_config.json"), "w", encoding="utf-8") as f:
json.dump(self.to_dict(), f, indent=2)
@classmethod
def from_pretrained(cls, save_dir: str, **kwargs):
# Parameters related to loading from Hugging Face Hub
cache_dir = kwargs.pop("cache_dir", None)
force_download = kwargs.pop("force_download", False)
resume_download = kwargs.pop("resume_download", False)
proxies = kwargs.pop("proxies", None)
local_files_only = kwargs.pop("local_files_only", False)
use_auth_token = kwargs.pop("use_auth_token", None)
revision = kwargs.pop("revision", None)
subfolder = kwargs.pop("subfolder", None)
commit_hash = kwargs.pop("_commit_hash", None)
transformers_config = False
for quantize_config_filename in [
"quantize_config.json",
"quant_config.json",
"config.json",
]:
if os.path.isdir(save_dir): # Local
resolved_config_file = join(save_dir, quantize_config_filename)
else: # Remote
resolved_config_file = cached_file(
save_dir,
quantize_config_filename,
cache_dir=cache_dir,
force_download=force_download,
resume_download=resume_download,
proxies=proxies,
use_auth_token=use_auth_token,
revision=revision,
local_files_only=local_files_only,
subfolder=subfolder,
_raise_exceptions_for_missing_entries=False,
_raise_exceptions_for_connection_errors=False,
_commit_hash=commit_hash,
)
if resolved_config_file is not None:
if quantize_config_filename == "config.json":
transformers_config = True
break
if resolved_config_file is None:
raise ValueError(
"No quantize_config.json, quant_config.json or config.json file was found in the model repository."
)
field_names = [field.name for field in fields(cls)]
with open(resolved_config_file, "r", encoding="utf-8") as f:
args_from_json = json.load(f)
if transformers_config:
args_from_json = args_from_json["quantization_config"]
filtered_args = {"awq_gemm_checkpoint": False}
for key, val in args_from_json.items():
if key == "version" and val == "GEMM":
filtered_args["awq_gemm_checkpoint"] = True
elif key in field_names:
filtered_args[key] = val
elif key in SYNONYMS and SYNONYMS[key] in field_names:
filtered_args[SYNONYMS[key]] = val
else:
logger.warning(f"ignoring unknown parameter in {quantize_config_filename}: {key}.")
if filtered_args["awq_gemm_checkpoint"]:
# AWQ does not reorder the rows.
filtered_args["desc_act"] = False
if "sym" not in args_from_json:
logger.warning(
f"The quantization configuration {quantize_config_filename} does not contain an entry `sym` (symetric quantization). This may result in silent errors."
)
return cls(**filtered_args)
def to_dict(self):
return {
"bits": self.bits,
"group_size": self.group_size,
"damp_percent": self.damp_percent,
"desc_act": self.desc_act,
"static_groups": self.static_groups,
"sym": self.sym,
"true_sequential": self.true_sequential,
"model_name_or_path": self.model_name_or_path,
"model_file_base_name": self.model_file_base_name,
"is_marlin_format": self.is_marlin_format,
"quant_method": "gptq",
}
| (self, other) |
21,640 | auto_gptq.modeling._base | __post_init__ | null | def __post_init__(self):
fields_info = fields(self)
if self.bits not in fields_info[0].metadata["choices"]:
raise ValueError(f"only support quantize to {fields_info[0].metadata['choices']} bits.")
if self.group_size != -1 and self.group_size <= 0:
raise ValueError("unless equal to -1, group_size must greater then 0.")
if not (0 < self.damp_percent < 1):
raise ValueError("damp_percent must between 0 and 1.")
| (self) |
21,641 | auto_gptq.modeling._base | __repr__ | null | def __init__(
self,
model: PreTrainedModel,
quantized: bool,
quantize_config: BaseQuantizeConfig,
is_triton_backend: bool = False,
injected_fused_attention: bool = False,
injected_fused_mlp: bool = False,
trainable: bool = False,
):
super().__init__()
self.model = model
self.model_type = self.model.config.model_type
self._quantized = quantized
self.quantize_config = quantize_config
self.config = self.model.config
self.is_triton_backend = is_triton_backend
self.injected_fused_attention = injected_fused_attention
self.injected_fused_mlp = injected_fused_mlp
self.trainable = trainable
| (self) |
21,645 | transformers.utils.hub | push_to_hub |
Upload the {object_files} to the 🤗 Model Hub.
Parameters:
repo_id (`str`):
The name of the repository you want to push your {object} to. It should contain your organization name
when pushing to a given organization.
use_temp_dir (`bool`, *optional*):
Whether or not to use a temporary directory to store the files saved before they are pushed to the Hub.
Will default to `True` if there is no directory named like `repo_id`, `False` otherwise.
commit_message (`str`, *optional*):
Message to commit while pushing. Will default to `"Upload {object}"`.
private (`bool`, *optional*):
Whether or not the repository created should be private.
token (`bool` or `str`, *optional*):
The token to use as HTTP bearer authorization for remote files. If `True`, will use the token generated
when running `huggingface-cli login` (stored in `~/.huggingface`). Will default to `True` if `repo_url`
is not specified.
max_shard_size (`int` or `str`, *optional*, defaults to `"5GB"`):
Only applicable for models. The maximum size for a checkpoint before being sharded. Checkpoints shard
will then be each of size lower than this size. If expressed as a string, needs to be digits followed
by a unit (like `"5MB"`). We default it to `"5GB"` so that users can easily load models on free-tier
Google Colab instances without any CPU OOM issues.
create_pr (`bool`, *optional*, defaults to `False`):
Whether or not to create a PR with the uploaded files or directly commit.
safe_serialization (`bool`, *optional*, defaults to `True`):
Whether or not to convert the model weights in safetensors format for safer serialization.
revision (`str`, *optional*):
Branch to push the uploaded files to.
commit_description (`str`, *optional*):
The description of the commit that will be created
tags (`List[str]`, *optional*):
List of tags to push on the Hub.
Examples:
```python
from transformers import {object_class}
{object} = {object_class}.from_pretrained("google-bert/bert-base-cased")
# Push the {object} to your namespace with the name "my-finetuned-bert".
{object}.push_to_hub("my-finetuned-bert")
# Push the {object} to an organization with the name "my-finetuned-bert".
{object}.push_to_hub("huggingface/my-finetuned-bert")
```
| def push_to_hub(
self,
repo_id: str,
use_temp_dir: Optional[bool] = None,
commit_message: Optional[str] = None,
private: Optional[bool] = None,
token: Optional[Union[bool, str]] = None,
max_shard_size: Optional[Union[int, str]] = "5GB",
create_pr: bool = False,
safe_serialization: bool = True,
revision: str = None,
commit_description: str = None,
tags: Optional[List[str]] = None,
**deprecated_kwargs,
) -> str:
"""
Upload the {object_files} to the 🤗 Model Hub.
Parameters:
repo_id (`str`):
The name of the repository you want to push your {object} to. It should contain your organization name
when pushing to a given organization.
use_temp_dir (`bool`, *optional*):
Whether or not to use a temporary directory to store the files saved before they are pushed to the Hub.
Will default to `True` if there is no directory named like `repo_id`, `False` otherwise.
commit_message (`str`, *optional*):
Message to commit while pushing. Will default to `"Upload {object}"`.
private (`bool`, *optional*):
Whether or not the repository created should be private.
token (`bool` or `str`, *optional*):
The token to use as HTTP bearer authorization for remote files. If `True`, will use the token generated
when running `huggingface-cli login` (stored in `~/.huggingface`). Will default to `True` if `repo_url`
is not specified.
max_shard_size (`int` or `str`, *optional*, defaults to `"5GB"`):
Only applicable for models. The maximum size for a checkpoint before being sharded. Checkpoints shard
will then be each of size lower than this size. If expressed as a string, needs to be digits followed
by a unit (like `"5MB"`). We default it to `"5GB"` so that users can easily load models on free-tier
Google Colab instances without any CPU OOM issues.
create_pr (`bool`, *optional*, defaults to `False`):
Whether or not to create a PR with the uploaded files or directly commit.
safe_serialization (`bool`, *optional*, defaults to `True`):
Whether or not to convert the model weights in safetensors format for safer serialization.
revision (`str`, *optional*):
Branch to push the uploaded files to.
commit_description (`str`, *optional*):
The description of the commit that will be created
tags (`List[str]`, *optional*):
List of tags to push on the Hub.
Examples:
```python
from transformers import {object_class}
{object} = {object_class}.from_pretrained("google-bert/bert-base-cased")
# Push the {object} to your namespace with the name "my-finetuned-bert".
{object}.push_to_hub("my-finetuned-bert")
# Push the {object} to an organization with the name "my-finetuned-bert".
{object}.push_to_hub("huggingface/my-finetuned-bert")
```
"""
use_auth_token = deprecated_kwargs.pop("use_auth_token", None)
ignore_metadata_errors = deprecated_kwargs.pop("ignore_metadata_errors", False)
if use_auth_token is not None:
warnings.warn(
"The `use_auth_token` argument is deprecated and will be removed in v5 of Transformers. Please use `token` instead.",
FutureWarning,
)
if token is not None:
raise ValueError(
"`token` and `use_auth_token` are both specified. Please set only the argument `token`."
)
token = use_auth_token
repo_path_or_name = deprecated_kwargs.pop("repo_path_or_name", None)
if repo_path_or_name is not None:
# Should use `repo_id` instead of `repo_path_or_name`. When using `repo_path_or_name`, we try to infer
# repo_id from the folder path, if it exists.
warnings.warn(
"The `repo_path_or_name` argument is deprecated and will be removed in v5 of Transformers. Use "
"`repo_id` instead.",
FutureWarning,
)
if repo_id is not None:
raise ValueError(
"`repo_id` and `repo_path_or_name` are both specified. Please set only the argument `repo_id`."
)
if os.path.isdir(repo_path_or_name):
# repo_path: infer repo_id from the path
repo_id = repo_id.split(os.path.sep)[-1]
working_dir = repo_id
else:
# repo_name: use it as repo_id
repo_id = repo_path_or_name
working_dir = repo_id.split("/")[-1]
else:
# Repo_id is passed correctly: infer working_dir from it
working_dir = repo_id.split("/")[-1]
# Deprecation warning will be sent after for repo_url and organization
repo_url = deprecated_kwargs.pop("repo_url", None)
organization = deprecated_kwargs.pop("organization", None)
repo_id = self._create_repo(
repo_id, private=private, token=token, repo_url=repo_url, organization=organization
)
# Create a new empty model card and eventually tag it
model_card = create_and_tag_model_card(
repo_id, tags, token=token, ignore_metadata_errors=ignore_metadata_errors
)
if use_temp_dir is None:
use_temp_dir = not os.path.isdir(working_dir)
with working_or_temp_dir(working_dir=working_dir, use_temp_dir=use_temp_dir) as work_dir:
files_timestamps = self._get_files_timestamps(work_dir)
# Save all files.
self.save_pretrained(work_dir, max_shard_size=max_shard_size, safe_serialization=safe_serialization)
# Update model card if needed:
model_card.save(os.path.join(work_dir, "README.md"))
return self._upload_modified_files(
work_dir,
repo_id,
files_timestamps,
commit_message=commit_message,
token=token,
create_pr=create_pr,
revision=revision,
commit_description=commit_description,
)
| (self, repo_id: str, use_temp_dir: Optional[bool] = None, commit_message: Optional[str] = None, private: Optional[bool] = None, token: Union[bool, str, NoneType] = None, max_shard_size: Union[int, str, NoneType] = '5GB', create_pr: bool = False, safe_serialization: bool = True, revision: Optional[str] = None, commit_description: Optional[str] = None, tags: Optional[List[str]] = None, **deprecated_kwargs) -> str |
21,646 | auto_gptq.modeling._base | save_pretrained | null | def save_pretrained(self, save_dir: str, **kwargs):
with open(join(save_dir, "quantize_config.json"), "w", encoding="utf-8") as f:
json.dump(self.to_dict(), f, indent=2)
| (self, save_dir: str, **kwargs) |
21,647 | auto_gptq.modeling._base | to_dict | null | def to_dict(self):
return {
"bits": self.bits,
"group_size": self.group_size,
"damp_percent": self.damp_percent,
"desc_act": self.desc_act,
"static_groups": self.static_groups,
"sym": self.sym,
"true_sequential": self.true_sequential,
"model_name_or_path": self.model_name_or_path,
"model_file_base_name": self.model_file_base_name,
"is_marlin_format": self.is_marlin_format,
"quant_method": "gptq",
}
| (self) |
21,648 | auto_gptq.utils.exllama_utils | exllama_set_max_input_length |
This method does not necessarily require `model` to inherit from BaseGPTQForCausalLM.
When using the exllama backend with act-order, it is necessary to initialize a buffer that depends on the maximum expected input length. In case the
default used (EXLLAMA_DEFAULT_MAX_INPUT_LENGTH) is too short, this method can be called to extend the buffer size without reloading the whole model.
| def exllama_set_max_input_length(model, max_input_length: int):
"""
This method does not necessarily require `model` to inherit from BaseGPTQForCausalLM.
When using the exllama backend with act-order, it is necessary to initialize a buffer that depends on the maximum expected input length. In case the
default used (EXLLAMA_DEFAULT_MAX_INPUT_LENGTH) is too short, this method can be called to extend the buffer size without reloading the whole model.
"""
# The import is set here to avoid a global import. Arguably this is quite ugly, it would be better to have lazy loading.
from exllama_kernels import cleanup_buffers_cuda, prepare_buffers
if not model.quantize_config.desc_act:
raise ValueError(
"The method exllama_set_max_input_length should be called only when using the exllama backend **with act-order**."
)
uses_exllama = False
for name, submodule in model.named_modules():
if isinstance(submodule, ExllamaQuantLinear):
uses_exllama = True
if not uses_exllama:
raise ValueError(
f"The function exllama_set_max_input_length was called, but the model (instance of {model.__class__.__name__}) does not use the exllama backend for GPTQ. An other implementation is used (exllamav2, cuda, cuda-old, triton) and that the call to exllama_set_max_input_length is unnecessary. Please remove the call to exllama_set_max_input_length or use the exllama v1 backend."
)
device_to_buffers_size = {}
for device, buffers in model.device_to_buffers.items():
device_to_buffers_size[device] = {
"max_dq_buffer_size": buffers["max_dq_buffer_size"],
"max_inner_outer_dim": buffers["max_inner_outer_dim"],
}
# For an unknown reason calling just `del model.device_to_buffers` raises an AttributeError.
for key in list(model.device_to_buffers.keys()):
del model.device_to_buffers[key]
model.device_to_buffers = None
del model.device_to_buffers
gc.collect()
torch.cuda.empty_cache()
cleanup_buffers_cuda()
device_to_buffers = {}
for device, buffers_size in device_to_buffers_size.items():
# The temp_state buffer is required to reorder X in the act-order case.
# The temp_dq buffer is required to dequantize weights when using cuBLAS, typically for the prefill.
device_to_buffers[device] = {
"temp_state": torch.zeros(
(max_input_length, buffers_size["max_inner_outer_dim"]),
dtype=torch.float16,
device=device,
),
"temp_dq": torch.zeros(
(1, buffers_size["max_dq_buffer_size"]),
dtype=torch.float16,
device=device,
),
"max_dq_buffer_size": buffers_size["max_dq_buffer_size"],
"max_inner_outer_dim": buffers_size["max_inner_outer_dim"],
}
prepare_buffers(
device,
device_to_buffers[device]["temp_state"],
device_to_buffers[device]["temp_dq"],
)
# Buffers need to be persistent to avoid any bug.
model.device_to_buffers = device_to_buffers
return model
| (model, max_input_length: int) |
21,649 | auto_gptq.utils.peft_utils | get_gptq_peft_model | null | def get_gptq_peft_model(
model: BaseGPTQForCausalLM,
peft_config: PeftConfig = None,
model_id: str = None,
adapter_name: str = "default",
auto_find_all_linears: bool = True,
train_mode: bool = False,
):
if train_mode and not model.trainable:
model.enable_trainable_mode()
if train_mode and not peft_config:
raise ValueError("peft_config not specified when in train mode.")
if not train_mode and not model_id:
raise ValueError("model_id(where to load adapters) not specified when in inference mode.")
if model.fused_attn_module_type is not None and not model.injected_fused_attention:
peft_types = [PeftType.LORA.value, PeftType.ADALORA.value]
warnings.warn(
f"You can just ignore this warning if the peft type you use isn't in {peft_types}.\n"
f"{model.__class__.__name__} supports injecting fused attention but not enables this time. "
"If you are training adapters, you must also disable fused attention injection when loading quantized "
"base model at inference time, otherwise adapters may not be added to base model properly. "
"If you are loading adapters to do inference, you can reference to adapter's config file to check "
"whether the adapters are trained using base model that not enable fused attention injection."
)
if model.injected_fused_mlp:
raise NotImplementedError(
"GPTQ model that enables fused mlp injection is not supported to integrate with peft."
)
if train_mode:
peft_type = peft_config.peft_type
if not isinstance(peft_type, str):
peft_type = peft_type.value
if peft_type in [PeftType.LORA.value, PeftType.ADALORA.value]:
if auto_find_all_linears:
peft_config.target_modules = find_all_linear_names(model, ignore_lm_head=True)
if peft_type == PeftType.LORA.value and not isinstance(peft_config, GPTQLoraConfig):
peft_config = GPTQLoraConfig(**peft_config.to_dict())
if peft_type == PeftType.ADALORA.value and not isinstance(peft_config, GPTQAdaLoraConfig):
peft_config = GPTQAdaLoraConfig(**peft_config.to_dict())
peft_config.injected_fused_attention = model.injected_fused_attention
peft_config.injected_fused_mlp = model.injected_fused_mlp
if peft_type == PeftType.ADAPTION_PROMPT.value:
if peft_config.adapter_layers > model.config.num_hidden_layers:
warnings.warn(
f"model has only {model.config.num_hidden_layers} layers "
f"but adapter_layers is set to {peft_config.adapter_layers}, "
f"will reset value to {model.config.num_hidden_layers}."
)
peft_config.adapter_layers = model.config.num_hidden_layers
if model.injected_fused_attention:
raise NotImplementedError(
"model with fused attention injected isn't supported to use ADAPTION_PROMPT peft type yet."
)
with hijack_peft_mappings():
try:
if train_mode:
peft_model = get_peft_model(model.model, peft_config, adapter_name=adapter_name)
else:
peft_model = PeftModel.from_pretrained(model.model, model_id, adapter_name)
except:
raise
raise NotImplementedError(
f"{model.__class__.__name__} not support {peft_config.peft_type.value} peft type yet."
)
return peft_model
| (model: auto_gptq.modeling._base.BaseGPTQForCausalLM, peft_config: Optional[peft.config.PeftConfig] = None, model_id: Optional[str] = None, adapter_name: str = 'default', auto_find_all_linears: bool = True, train_mode: bool = False) |
21,654 | magic_filter.attrdict | AttrDict |
A wrapper over dict which where element can be accessed as regular attributes
| class AttrDict(Dict[KT, VT]):
"""
A wrapper over dict which where element can be accessed as regular attributes
"""
def __init__(self, *args: Any, **kwargs: Any) -> None:
super(AttrDict, self).__init__(*args, **kwargs)
self.__dict__ = self # type: ignore
| (*args: Any, **kwargs: Any) -> None |
21,655 | magic_filter.attrdict | __init__ | null | def __init__(self, *args: Any, **kwargs: Any) -> None:
super(AttrDict, self).__init__(*args, **kwargs)
self.__dict__ = self # type: ignore
| (self, *args: Any, **kwargs: Any) -> NoneType |
21,656 | magic_filter.magic | MagicFilter | null | class MagicFilter:
__slots__ = ("_operations",)
def __init__(self, operations: Tuple[BaseOperation, ...] = ()) -> None:
self._operations = operations
# An instance of MagicFilter cannot be used as an iterable object because objects
# with a __getitem__ method can be endlessly iterated, which is not the desired behavior.
__iter__ = None
@classmethod
def ilter(cls, magic: "MagicFilter") -> Callable[[Any], Any]:
@wraps(magic.resolve)
def wrapper(value: Any) -> Any:
return magic.resolve(value)
return wrapper
@classmethod
def _new(cls: Type[MagicT], operations: Tuple[BaseOperation, ...]) -> MagicT:
return cls(operations=operations)
def _extend(self: MagicT, operation: BaseOperation) -> MagicT:
return self._new(self._operations + (operation,))
def _replace_last(self: MagicT, operation: BaseOperation) -> MagicT:
return self._new(self._operations[:-1] + (operation,))
def _exclude_last(self: MagicT) -> MagicT:
return self._new(self._operations[:-1])
def _resolve(self, value: Any, operations: Optional[Tuple[BaseOperation, ...]] = None) -> Any:
initial_value = value
if operations is None:
operations = self._operations
rejected = False
for index, operation in enumerate(operations):
if rejected and not operation.important:
continue
try:
value = operation.resolve(value=value, initial_value=initial_value)
except SwitchModeToAll:
return all(self._resolve(value=item, operations=operations[index + 1 :]) for item in value)
except SwitchModeToAny:
return any(self._resolve(value=item, operations=operations[index + 1 :]) for item in value)
except RejectOperations:
rejected = True
value = None
continue
rejected = False
return value
def __bool__(self) -> bool:
return True
def resolve(self: MagicT, value: Any) -> Any:
return self._resolve(value=value)
def __getattr__(self: MagicT, item: Any) -> MagicT:
if item.startswith("_"):
raise AttributeError(f"{type(self).__name__!r} object has no attribute {item!r}")
return self._extend(GetAttributeOperation(name=item))
attr_ = __getattr__
def __getitem__(self: MagicT, item: Any) -> MagicT:
if isinstance(item, MagicFilter):
return self._extend(SelectorOperation(inner=item))
return self._extend(GetItemOperation(key=item))
def __len__(self) -> int:
raise TypeError(f"Length can't be taken using len() function. Use {type(self).__name__}.len() instead.")
def __eq__(self: MagicT, other: Any) -> MagicT: # type: ignore
return self._extend(ComparatorOperation(right=other, comparator=operator.eq))
def __ne__(self: MagicT, other: Any) -> MagicT: # type: ignore
return self._extend(ComparatorOperation(right=other, comparator=operator.ne))
def __lt__(self: MagicT, other: Any) -> MagicT:
return self._extend(ComparatorOperation(right=other, comparator=operator.lt))
def __gt__(self: MagicT, other: Any) -> MagicT:
return self._extend(ComparatorOperation(right=other, comparator=operator.gt))
def __le__(self: MagicT, other: Any) -> MagicT:
return self._extend(ComparatorOperation(right=other, comparator=operator.le))
def __ge__(self: MagicT, other: Any) -> MagicT:
return self._extend(ComparatorOperation(right=other, comparator=operator.ge))
def __invert__(self: MagicT) -> MagicT:
if (
self._operations
and isinstance(self._operations[-1], ImportantFunctionOperation)
and self._operations[-1].function == operator.not_
):
return self._exclude_last()
return self._extend(ImportantFunctionOperation(function=operator.not_))
def __call__(self: MagicT, *args: Any, **kwargs: Any) -> MagicT:
return self._extend(CallOperation(args=args, kwargs=kwargs))
def __and__(self: MagicT, other: Any) -> MagicT:
if isinstance(other, MagicFilter):
return self._extend(CombinationOperation(right=other, combinator=and_op))
return self._extend(CombinationOperation(right=other, combinator=operator.and_))
def __rand__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.and_))
def __or__(self: MagicT, other: Any) -> MagicT:
if isinstance(other, MagicFilter):
return self._extend(ImportantCombinationOperation(right=other, combinator=or_op))
return self._extend(ImportantCombinationOperation(right=other, combinator=operator.or_))
def __ror__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.or_))
def __xor__(self: MagicT, other: Any) -> MagicT:
return self._extend(CombinationOperation(right=other, combinator=operator.xor))
def __rxor__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.xor))
def __rshift__(self: MagicT, other: Any) -> MagicT:
return self._extend(CombinationOperation(right=other, combinator=operator.rshift))
def __rrshift__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.rshift))
def __lshift__(self: MagicT, other: Any) -> MagicT:
return self._extend(CombinationOperation(right=other, combinator=operator.lshift))
def __rlshift__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.lshift))
def __add__(self: MagicT, other: Any) -> MagicT:
return self._extend(CombinationOperation(right=other, combinator=operator.add))
def __radd__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.add))
def __sub__(self: MagicT, other: Any) -> MagicT:
return self._extend(CombinationOperation(right=other, combinator=operator.sub))
def __rsub__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.sub))
def __mul__(self: MagicT, other: Any) -> MagicT:
return self._extend(CombinationOperation(right=other, combinator=operator.mul))
def __rmul__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.mul))
def __truediv__(self: MagicT, other: Any) -> MagicT:
return self._extend(CombinationOperation(right=other, combinator=operator.truediv))
def __rtruediv__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.truediv))
def __floordiv__(self: MagicT, other: Any) -> MagicT:
return self._extend(CombinationOperation(right=other, combinator=operator.floordiv))
def __rfloordiv__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.floordiv))
def __mod__(self: MagicT, other: Any) -> MagicT:
return self._extend(CombinationOperation(right=other, combinator=operator.mod))
def __rmod__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.mod))
def __matmul__(self: MagicT, other: Any) -> MagicT:
return self._extend(CombinationOperation(right=other, combinator=operator.matmul))
def __rmatmul__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.matmul))
def __pow__(self: MagicT, other: Any) -> MagicT:
return self._extend(CombinationOperation(right=other, combinator=operator.pow))
def __rpow__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.pow))
def __pos__(self: MagicT) -> MagicT:
return self._extend(FunctionOperation(function=operator.pos))
def __neg__(self: MagicT) -> MagicT:
return self._extend(FunctionOperation(function=operator.neg))
def is_(self: MagicT, value: Any) -> MagicT:
return self._extend(CombinationOperation(right=value, combinator=operator.is_))
def is_not(self: MagicT, value: Any) -> MagicT:
return self._extend(CombinationOperation(right=value, combinator=operator.is_not))
def in_(self: MagicT, iterable: Union[Container[Any], MagicT]) -> MagicT:
return self._extend(FunctionOperation(in_op, iterable))
def not_in(self: MagicT, iterable: Union[Container[Any], MagicT]) -> MagicT:
return self._extend(FunctionOperation(not_in_op, iterable))
def contains(self: MagicT, value: Any) -> MagicT:
return self._extend(FunctionOperation(contains_op, value))
def not_contains(self: MagicT, value: Any) -> MagicT:
return self._extend(FunctionOperation(not_contains_op, value))
def len(self: MagicT) -> MagicT:
return self._extend(FunctionOperation(len))
def regexp(
self: MagicT,
pattern: Union[str, Pattern[str]],
*,
mode: Optional[str] = None,
search: Optional[bool] = None,
flags: Union[int, re.RegexFlag] = 0,
) -> MagicT:
if search is not None:
warn(
"Param 'search' is deprecated, use 'mode' instead.",
DeprecationWarning,
)
if mode is not None:
msg = "Can't pass both 'search' and 'mode' params."
raise ParamsConflict(msg)
mode = RegexpMode.SEARCH if search else RegexpMode.MATCH
if mode is None:
mode = RegexpMode.MATCH
if isinstance(pattern, str):
pattern = re.compile(pattern, flags=flags)
regexp_func = getattr(pattern, mode)
return self._extend(FunctionOperation(regexp_func))
def func(self: MagicT, func: Callable[[Any], Any], *args: Any, **kwargs: Any) -> MagicT:
return self._extend(FunctionOperation(func, *args, **kwargs))
def cast(self: MagicT, func: Callable[[Any], Any]) -> MagicT:
return self._extend(CastOperation(func))
def extract(self: MagicT, magic: "MagicT") -> MagicT:
return self._extend(ExtractOperation(magic))
| (operations: Tuple[magic_filter.operations.base.BaseOperation, ...] = ()) -> None |
21,657 | magic_filter.magic | __add__ | null | def __add__(self: MagicT, other: Any) -> MagicT:
return self._extend(CombinationOperation(right=other, combinator=operator.add))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,658 | magic_filter.magic | __and__ | null | def __and__(self: MagicT, other: Any) -> MagicT:
if isinstance(other, MagicFilter):
return self._extend(CombinationOperation(right=other, combinator=and_op))
return self._extend(CombinationOperation(right=other, combinator=operator.and_))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,659 | magic_filter.magic | __bool__ | null | def __bool__(self) -> bool:
return True
| (self) -> bool |
21,660 | magic_filter.magic | __call__ | null | def __call__(self: MagicT, *args: Any, **kwargs: Any) -> MagicT:
return self._extend(CallOperation(args=args, kwargs=kwargs))
| (self: ~MagicT, *args: Any, **kwargs: Any) -> ~MagicT |
21,661 | magic_filter.magic | __eq__ | null | def __eq__(self: MagicT, other: Any) -> MagicT: # type: ignore
return self._extend(ComparatorOperation(right=other, comparator=operator.eq))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,662 | magic_filter.magic | __floordiv__ | null | def __floordiv__(self: MagicT, other: Any) -> MagicT:
return self._extend(CombinationOperation(right=other, combinator=operator.floordiv))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,663 | magic_filter.magic | __ge__ | null | def __ge__(self: MagicT, other: Any) -> MagicT:
return self._extend(ComparatorOperation(right=other, comparator=operator.ge))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,664 | magic_filter.magic | __getattr__ | null | def __getattr__(self: MagicT, item: Any) -> MagicT:
if item.startswith("_"):
raise AttributeError(f"{type(self).__name__!r} object has no attribute {item!r}")
return self._extend(GetAttributeOperation(name=item))
| (self: ~MagicT, item: Any) -> ~MagicT |
21,665 | magic_filter.magic | __getitem__ | null | def __getitem__(self: MagicT, item: Any) -> MagicT:
if isinstance(item, MagicFilter):
return self._extend(SelectorOperation(inner=item))
return self._extend(GetItemOperation(key=item))
| (self: ~MagicT, item: Any) -> ~MagicT |
21,666 | magic_filter.magic | __gt__ | null | def __gt__(self: MagicT, other: Any) -> MagicT:
return self._extend(ComparatorOperation(right=other, comparator=operator.gt))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,667 | magic_filter.magic | __init__ | null | def __init__(self, operations: Tuple[BaseOperation, ...] = ()) -> None:
self._operations = operations
| (self, operations: Tuple[magic_filter.operations.base.BaseOperation, ...] = ()) -> NoneType |
21,668 | magic_filter.magic | __invert__ | null | def __invert__(self: MagicT) -> MagicT:
if (
self._operations
and isinstance(self._operations[-1], ImportantFunctionOperation)
and self._operations[-1].function == operator.not_
):
return self._exclude_last()
return self._extend(ImportantFunctionOperation(function=operator.not_))
| (self: ~MagicT) -> ~MagicT |
21,669 | magic_filter.magic | __le__ | null | def __le__(self: MagicT, other: Any) -> MagicT:
return self._extend(ComparatorOperation(right=other, comparator=operator.le))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,670 | magic_filter.magic | __len__ | null | def __len__(self) -> int:
raise TypeError(f"Length can't be taken using len() function. Use {type(self).__name__}.len() instead.")
| (self) -> int |
21,671 | magic_filter.magic | __lshift__ | null | def __lshift__(self: MagicT, other: Any) -> MagicT:
return self._extend(CombinationOperation(right=other, combinator=operator.lshift))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,672 | magic_filter.magic | __lt__ | null | def __lt__(self: MagicT, other: Any) -> MagicT:
return self._extend(ComparatorOperation(right=other, comparator=operator.lt))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,673 | magic_filter.magic | __matmul__ | null | def __matmul__(self: MagicT, other: Any) -> MagicT:
return self._extend(CombinationOperation(right=other, combinator=operator.matmul))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,674 | magic_filter.magic | __mod__ | null | def __mod__(self: MagicT, other: Any) -> MagicT:
return self._extend(CombinationOperation(right=other, combinator=operator.mod))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,675 | magic_filter.magic | __mul__ | null | def __mul__(self: MagicT, other: Any) -> MagicT:
return self._extend(CombinationOperation(right=other, combinator=operator.mul))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,676 | magic_filter.magic | __ne__ | null | def __ne__(self: MagicT, other: Any) -> MagicT: # type: ignore
return self._extend(ComparatorOperation(right=other, comparator=operator.ne))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,677 | magic_filter.magic | __neg__ | null | def __neg__(self: MagicT) -> MagicT:
return self._extend(FunctionOperation(function=operator.neg))
| (self: ~MagicT) -> ~MagicT |
21,678 | magic_filter.magic | __or__ | null | def __or__(self: MagicT, other: Any) -> MagicT:
if isinstance(other, MagicFilter):
return self._extend(ImportantCombinationOperation(right=other, combinator=or_op))
return self._extend(ImportantCombinationOperation(right=other, combinator=operator.or_))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,679 | magic_filter.magic | __pos__ | null | def __pos__(self: MagicT) -> MagicT:
return self._extend(FunctionOperation(function=operator.pos))
| (self: ~MagicT) -> ~MagicT |
21,680 | magic_filter.magic | __pow__ | null | def __pow__(self: MagicT, other: Any) -> MagicT:
return self._extend(CombinationOperation(right=other, combinator=operator.pow))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,681 | magic_filter.magic | __radd__ | null | def __radd__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.add))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,682 | magic_filter.magic | __rand__ | null | def __rand__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.and_))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,683 | magic_filter.magic | __rfloordiv__ | null | def __rfloordiv__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.floordiv))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,684 | magic_filter.magic | __rlshift__ | null | def __rlshift__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.lshift))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,685 | magic_filter.magic | __rmatmul__ | null | def __rmatmul__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.matmul))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,686 | magic_filter.magic | __rmod__ | null | def __rmod__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.mod))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,687 | magic_filter.magic | __rmul__ | null | def __rmul__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.mul))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,688 | magic_filter.magic | __ror__ | null | def __ror__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.or_))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,689 | magic_filter.magic | __rpow__ | null | def __rpow__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.pow))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,690 | magic_filter.magic | __rrshift__ | null | def __rrshift__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.rshift))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,691 | magic_filter.magic | __rshift__ | null | def __rshift__(self: MagicT, other: Any) -> MagicT:
return self._extend(CombinationOperation(right=other, combinator=operator.rshift))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,692 | magic_filter.magic | __rsub__ | null | def __rsub__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.sub))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,693 | magic_filter.magic | __rtruediv__ | null | def __rtruediv__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.truediv))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,694 | magic_filter.magic | __rxor__ | null | def __rxor__(self: MagicT, other: Any) -> MagicT:
return self._extend(RCombinationOperation(left=other, combinator=operator.xor))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,695 | magic_filter.magic | __sub__ | null | def __sub__(self: MagicT, other: Any) -> MagicT:
return self._extend(CombinationOperation(right=other, combinator=operator.sub))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,696 | magic_filter.magic | __truediv__ | null | def __truediv__(self: MagicT, other: Any) -> MagicT:
return self._extend(CombinationOperation(right=other, combinator=operator.truediv))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,697 | magic_filter.magic | __xor__ | null | def __xor__(self: MagicT, other: Any) -> MagicT:
return self._extend(CombinationOperation(right=other, combinator=operator.xor))
| (self: ~MagicT, other: Any) -> ~MagicT |
21,698 | magic_filter.magic | _exclude_last | null | def _exclude_last(self: MagicT) -> MagicT:
return self._new(self._operations[:-1])
| (self: ~MagicT) -> ~MagicT |
21,699 | magic_filter.magic | _extend | null | def _extend(self: MagicT, operation: BaseOperation) -> MagicT:
return self._new(self._operations + (operation,))
| (self: ~MagicT, operation: magic_filter.operations.base.BaseOperation) -> ~MagicT |
21,700 | magic_filter.magic | _replace_last | null | def _replace_last(self: MagicT, operation: BaseOperation) -> MagicT:
return self._new(self._operations[:-1] + (operation,))
| (self: ~MagicT, operation: magic_filter.operations.base.BaseOperation) -> ~MagicT |
21,701 | magic_filter.magic | _resolve | null | def _resolve(self, value: Any, operations: Optional[Tuple[BaseOperation, ...]] = None) -> Any:
initial_value = value
if operations is None:
operations = self._operations
rejected = False
for index, operation in enumerate(operations):
if rejected and not operation.important:
continue
try:
value = operation.resolve(value=value, initial_value=initial_value)
except SwitchModeToAll:
return all(self._resolve(value=item, operations=operations[index + 1 :]) for item in value)
except SwitchModeToAny:
return any(self._resolve(value=item, operations=operations[index + 1 :]) for item in value)
except RejectOperations:
rejected = True
value = None
continue
rejected = False
return value
| (self, value: Any, operations: Optional[Tuple[magic_filter.operations.base.BaseOperation, ...]] = None) -> Any |
21,703 | magic_filter.magic | cast | null | def cast(self: MagicT, func: Callable[[Any], Any]) -> MagicT:
return self._extend(CastOperation(func))
| (self: ~MagicT, func: Callable[[Any], Any]) -> ~MagicT |
21,704 | magic_filter.magic | contains | null | def contains(self: MagicT, value: Any) -> MagicT:
return self._extend(FunctionOperation(contains_op, value))
| (self: ~MagicT, value: Any) -> ~MagicT |
21,705 | magic_filter.magic | extract | null | def extract(self: MagicT, magic: "MagicT") -> MagicT:
return self._extend(ExtractOperation(magic))
| (self: ~MagicT, magic: ~MagicT) -> ~MagicT |
21,706 | magic_filter.magic | func | null | def func(self: MagicT, func: Callable[[Any], Any], *args: Any, **kwargs: Any) -> MagicT:
return self._extend(FunctionOperation(func, *args, **kwargs))
| (self: ~MagicT, func: Callable[[Any], Any], *args: Any, **kwargs: Any) -> ~MagicT |
21,707 | magic_filter.magic | in_ | null | def in_(self: MagicT, iterable: Union[Container[Any], MagicT]) -> MagicT:
return self._extend(FunctionOperation(in_op, iterable))
| (self: ~MagicT, iterable: Union[Container[Any], ~MagicT]) -> ~MagicT |
21,708 | magic_filter.magic | is_ | null | def is_(self: MagicT, value: Any) -> MagicT:
return self._extend(CombinationOperation(right=value, combinator=operator.is_))
| (self: ~MagicT, value: Any) -> ~MagicT |
21,709 | magic_filter.magic | is_not | null | def is_not(self: MagicT, value: Any) -> MagicT:
return self._extend(CombinationOperation(right=value, combinator=operator.is_not))
| (self: ~MagicT, value: Any) -> ~MagicT |
21,710 | magic_filter.magic | len | null | def len(self: MagicT) -> MagicT:
return self._extend(FunctionOperation(len))
| (self: ~MagicT) -> ~MagicT |
21,711 | magic_filter.magic | not_contains | null | def not_contains(self: MagicT, value: Any) -> MagicT:
return self._extend(FunctionOperation(not_contains_op, value))
| (self: ~MagicT, value: Any) -> ~MagicT |
21,712 | magic_filter.magic | not_in | null | def not_in(self: MagicT, iterable: Union[Container[Any], MagicT]) -> MagicT:
return self._extend(FunctionOperation(not_in_op, iterable))
| (self: ~MagicT, iterable: Union[Container[Any], ~MagicT]) -> ~MagicT |
21,713 | magic_filter.magic | regexp | null | def regexp(
self: MagicT,
pattern: Union[str, Pattern[str]],
*,
mode: Optional[str] = None,
search: Optional[bool] = None,
flags: Union[int, re.RegexFlag] = 0,
) -> MagicT:
if search is not None:
warn(
"Param 'search' is deprecated, use 'mode' instead.",
DeprecationWarning,
)
if mode is not None:
msg = "Can't pass both 'search' and 'mode' params."
raise ParamsConflict(msg)
mode = RegexpMode.SEARCH if search else RegexpMode.MATCH
if mode is None:
mode = RegexpMode.MATCH
if isinstance(pattern, str):
pattern = re.compile(pattern, flags=flags)
regexp_func = getattr(pattern, mode)
return self._extend(FunctionOperation(regexp_func))
| (self: ~MagicT, pattern: Union[str, Pattern[str]], *, mode: Optional[str] = None, search: Optional[bool] = None, flags: Union[int, re.RegexFlag] = 0) -> ~MagicT |
21,714 | magic_filter.magic | resolve | null | def resolve(self: MagicT, value: Any) -> Any:
return self._resolve(value=value)
| (self: ~MagicT, value: Any) -> Any |
21,715 | magic_filter.magic | RegexpMode | null | class RegexpMode:
SEARCH = "search"
MATCH = "match"
FINDALL = "findall"
FINDITER = "finditer"
FULLMATCH = "fullmatch"
| () |
21,722 | basicauth | DecodeError | null | class DecodeError(Exception):
pass
| null |
21,723 | basicauth | EncodeError | null | class EncodeError(Exception):
pass
| null |
21,725 | base64 | b64encode | Encode the bytes-like object s using Base64 and return a bytes object.
Optional altchars should be a byte string of length 2 which specifies an
alternative alphabet for the '+' and '/' characters. This allows an
application to e.g. generate url or filesystem safe Base64 strings.
| def b64encode(s, altchars=None):
"""Encode the bytes-like object s using Base64 and return a bytes object.
Optional altchars should be a byte string of length 2 which specifies an
alternative alphabet for the '+' and '/' characters. This allows an
application to e.g. generate url or filesystem safe Base64 strings.
"""
encoded = binascii.b2a_base64(s, newline=False)
if altchars is not None:
assert len(altchars) == 2, repr(altchars)
return encoded.translate(bytes.maketrans(b'+/', altchars))
return encoded
| (s, altchars=None) |
21,726 | basicauth | decode | Decode an encrypted HTTP basic authentication string. Returns a tuple of
the form (username, password), and raises a DecodeError exception if
nothing could be decoded.
| def decode(encoded_str):
"""Decode an encrypted HTTP basic authentication string. Returns a tuple of
the form (username, password), and raises a DecodeError exception if
nothing could be decoded.
"""
split = encoded_str.strip().split(' ')
# If split is only one element, try to decode the username and password
# directly.
if len(split) == 1:
try:
username, password = b64decode(split[0]).decode().split(':', 1)
except:
raise DecodeError
# If there are only two elements, check the first and ensure it says
# 'basic' so that we know we're about to decode the right thing. If not,
# bail out.
elif len(split) == 2:
if split[0].strip().lower() == 'basic':
try:
username, password = b64decode(split[1]).decode().split(':', 1)
except:
raise DecodeError
else:
raise DecodeError
# If there are more than 2 elements, something crazy must be happening.
# Bail.
else:
raise DecodeError
return unquote(username), unquote(password)
| (encoded_str) |
21,727 | basicauth | encode | Returns an HTTP basic authentication encrypted string given a valid
username and password.
| def encode(username, password):
"""Returns an HTTP basic authentication encrypted string given a valid
username and password.
"""
if ':' in username:
raise EncodeError
username_password = f'{quote(username)}:{quote(password)}'
return f'Basic {b64encode(username_password.encode()).decode()}'
| (username, password) |
21,729 | urllib.parse | unquote | Replace %xx escapes by their single-character equivalent. The optional
encoding and errors parameters specify how to decode percent-encoded
sequences into Unicode characters, as accepted by the bytes.decode()
method.
By default, percent-encoded sequences are decoded with UTF-8, and invalid
sequences are replaced by a placeholder character.
unquote('abc%20def') -> 'abc def'.
| def unquote(string, encoding='utf-8', errors='replace'):
"""Replace %xx escapes by their single-character equivalent. The optional
encoding and errors parameters specify how to decode percent-encoded
sequences into Unicode characters, as accepted by the bytes.decode()
method.
By default, percent-encoded sequences are decoded with UTF-8, and invalid
sequences are replaced by a placeholder character.
unquote('abc%20def') -> 'abc def'.
"""
if isinstance(string, bytes):
return unquote_to_bytes(string).decode(encoding, errors)
if '%' not in string:
string.split
return string
if encoding is None:
encoding = 'utf-8'
if errors is None:
errors = 'replace'
bits = _asciire.split(string)
res = [bits[0]]
append = res.append
for i in range(1, len(bits), 2):
append(unquote_to_bytes(bits[i]).decode(encoding, errors))
append(bits[i + 1])
return ''.join(res)
| (string, encoding='utf-8', errors='replace') |
21,730 | aiosocks.errors | InvalidServerReply | null | class InvalidServerReply(SocksError):
pass
| null |
21,731 | aiosocks.errors | InvalidServerVersion | null | class InvalidServerVersion(SocksError):
pass
| null |
21,732 | aiosocks.errors | LoginAuthenticationFailed | null | class LoginAuthenticationFailed(SocksError):
pass
| null |
21,733 | aiosocks.errors | NoAcceptableAuthMethods | null | class NoAcceptableAuthMethods(SocksError):
pass
| null |
21,734 | aiosocks.helpers | Socks4Addr | null | class Socks4Addr(SocksAddr):
pass
| (host, port=1080) |
21,736 | aiosocks.helpers | __new__ | null | def __new__(cls, host, port=1080):
if host is None:
raise ValueError('None is not allowed as host value')
if port is None:
port = 1080 # default socks server port
return super().__new__(cls, host, port)
| (cls, host, port=1080) |
21,739 | collections | _replace | Return a new SocksServer object replacing specified fields with new values | def namedtuple(typename, field_names, *, rename=False, defaults=None, module=None):
"""Returns a new subclass of tuple with named fields.
>>> Point = namedtuple('Point', ['x', 'y'])
>>> Point.__doc__ # docstring for the new class
'Point(x, y)'
>>> p = Point(11, y=22) # instantiate with positional args or keywords
>>> p[0] + p[1] # indexable like a plain tuple
33
>>> x, y = p # unpack like a regular tuple
>>> x, y
(11, 22)
>>> p.x + p.y # fields also accessible by name
33
>>> d = p._asdict() # convert to a dictionary
>>> d['x']
11
>>> Point(**d) # convert from a dictionary
Point(x=11, y=22)
>>> p._replace(x=100) # _replace() is like str.replace() but targets named fields
Point(x=100, y=22)
"""
# Validate the field names. At the user's option, either generate an error
# message or automatically replace the field name with a valid name.
if isinstance(field_names, str):
field_names = field_names.replace(',', ' ').split()
field_names = list(map(str, field_names))
typename = _sys.intern(str(typename))
if rename:
seen = set()
for index, name in enumerate(field_names):
if (not name.isidentifier()
or _iskeyword(name)
or name.startswith('_')
or name in seen):
field_names[index] = f'_{index}'
seen.add(name)
for name in [typename] + field_names:
if type(name) is not str:
raise TypeError('Type names and field names must be strings')
if not name.isidentifier():
raise ValueError('Type names and field names must be valid '
f'identifiers: {name!r}')
if _iskeyword(name):
raise ValueError('Type names and field names cannot be a '
f'keyword: {name!r}')
seen = set()
for name in field_names:
if name.startswith('_') and not rename:
raise ValueError('Field names cannot start with an underscore: '
f'{name!r}')
if name in seen:
raise ValueError(f'Encountered duplicate field name: {name!r}')
seen.add(name)
field_defaults = {}
if defaults is not None:
defaults = tuple(defaults)
if len(defaults) > len(field_names):
raise TypeError('Got more default values than field names')
field_defaults = dict(reversed(list(zip(reversed(field_names),
reversed(defaults)))))
# Variables used in the methods and docstrings
field_names = tuple(map(_sys.intern, field_names))
num_fields = len(field_names)
arg_list = ', '.join(field_names)
if num_fields == 1:
arg_list += ','
repr_fmt = '(' + ', '.join(f'{name}=%r' for name in field_names) + ')'
tuple_new = tuple.__new__
_dict, _tuple, _len, _map, _zip = dict, tuple, len, map, zip
# Create all the named tuple methods to be added to the class namespace
namespace = {
'_tuple_new': tuple_new,
'__builtins__': {},
'__name__': f'namedtuple_{typename}',
}
code = f'lambda _cls, {arg_list}: _tuple_new(_cls, ({arg_list}))'
__new__ = eval(code, namespace)
__new__.__name__ = '__new__'
__new__.__doc__ = f'Create new instance of {typename}({arg_list})'
if defaults is not None:
__new__.__defaults__ = defaults
@classmethod
def _make(cls, iterable):
result = tuple_new(cls, iterable)
if _len(result) != num_fields:
raise TypeError(f'Expected {num_fields} arguments, got {len(result)}')
return result
_make.__func__.__doc__ = (f'Make a new {typename} object from a sequence '
'or iterable')
def _replace(self, /, **kwds):
result = self._make(_map(kwds.pop, field_names, self))
if kwds:
raise ValueError(f'Got unexpected field names: {list(kwds)!r}')
return result
_replace.__doc__ = (f'Return a new {typename} object replacing specified '
'fields with new values')
def __repr__(self):
'Return a nicely formatted representation string'
return self.__class__.__name__ + repr_fmt % self
def _asdict(self):
'Return a new dict which maps field names to their values.'
return _dict(_zip(self._fields, self))
def __getnewargs__(self):
'Return self as a plain tuple. Used by copy and pickle.'
return _tuple(self)
# Modify function metadata to help with introspection and debugging
for method in (
__new__,
_make.__func__,
_replace,
__repr__,
_asdict,
__getnewargs__,
):
method.__qualname__ = f'{typename}.{method.__name__}'
# Build-up the class namespace dictionary
# and use type() to build the result class
class_namespace = {
'__doc__': f'{typename}({arg_list})',
'__slots__': (),
'_fields': field_names,
'_field_defaults': field_defaults,
'__new__': __new__,
'_make': _make,
'_replace': _replace,
'__repr__': __repr__,
'_asdict': _asdict,
'__getnewargs__': __getnewargs__,
'__match_args__': field_names,
}
for index, name in enumerate(field_names):
doc = _sys.intern(f'Alias for field number {index}')
class_namespace[name] = _tuplegetter(index, doc)
result = type(typename, (tuple,), class_namespace)
# For pickling to work, the __module__ variable needs to be set to the frame
# where the named tuple is created. Bypass this step in environments where
# sys._getframe is not defined (Jython for example) or sys._getframe is not
# defined for arguments greater than 0 (IronPython), or where the user has
# specified a particular module.
if module is None:
try:
module = _sys._getframe(1).f_globals.get('__name__', '__main__')
except (AttributeError, ValueError):
pass
if module is not None:
result.__module__ = module
return result
| (self, /, **kwds) |
21,740 | aiosocks.helpers | Socks4Auth | null | class Socks4Auth(namedtuple('Socks4Auth', ['login', 'encoding'])):
def __new__(cls, login, encoding='utf-8'):
if login is None:
raise ValueError('None is not allowed as login value')
return super().__new__(cls, login.encode(encoding), encoding)
| (login, encoding='utf-8') |
21,742 | aiosocks.helpers | __new__ | null | def __new__(cls, login, encoding='utf-8'):
if login is None:
raise ValueError('None is not allowed as login value')
return super().__new__(cls, login.encode(encoding), encoding)
| (cls, login, encoding='utf-8') |
21,745 | collections | _replace | Return a new Socks4Auth object replacing specified fields with new values | def namedtuple(typename, field_names, *, rename=False, defaults=None, module=None):
"""Returns a new subclass of tuple with named fields.
>>> Point = namedtuple('Point', ['x', 'y'])
>>> Point.__doc__ # docstring for the new class
'Point(x, y)'
>>> p = Point(11, y=22) # instantiate with positional args or keywords
>>> p[0] + p[1] # indexable like a plain tuple
33
>>> x, y = p # unpack like a regular tuple
>>> x, y
(11, 22)
>>> p.x + p.y # fields also accessible by name
33
>>> d = p._asdict() # convert to a dictionary
>>> d['x']
11
>>> Point(**d) # convert from a dictionary
Point(x=11, y=22)
>>> p._replace(x=100) # _replace() is like str.replace() but targets named fields
Point(x=100, y=22)
"""
# Validate the field names. At the user's option, either generate an error
# message or automatically replace the field name with a valid name.
if isinstance(field_names, str):
field_names = field_names.replace(',', ' ').split()
field_names = list(map(str, field_names))
typename = _sys.intern(str(typename))
if rename:
seen = set()
for index, name in enumerate(field_names):
if (not name.isidentifier()
or _iskeyword(name)
or name.startswith('_')
or name in seen):
field_names[index] = f'_{index}'
seen.add(name)
for name in [typename] + field_names:
if type(name) is not str:
raise TypeError('Type names and field names must be strings')
if not name.isidentifier():
raise ValueError('Type names and field names must be valid '
f'identifiers: {name!r}')
if _iskeyword(name):
raise ValueError('Type names and field names cannot be a '
f'keyword: {name!r}')
seen = set()
for name in field_names:
if name.startswith('_') and not rename:
raise ValueError('Field names cannot start with an underscore: '
f'{name!r}')
if name in seen:
raise ValueError(f'Encountered duplicate field name: {name!r}')
seen.add(name)
field_defaults = {}
if defaults is not None:
defaults = tuple(defaults)
if len(defaults) > len(field_names):
raise TypeError('Got more default values than field names')
field_defaults = dict(reversed(list(zip(reversed(field_names),
reversed(defaults)))))
# Variables used in the methods and docstrings
field_names = tuple(map(_sys.intern, field_names))
num_fields = len(field_names)
arg_list = ', '.join(field_names)
if num_fields == 1:
arg_list += ','
repr_fmt = '(' + ', '.join(f'{name}=%r' for name in field_names) + ')'
tuple_new = tuple.__new__
_dict, _tuple, _len, _map, _zip = dict, tuple, len, map, zip
# Create all the named tuple methods to be added to the class namespace
namespace = {
'_tuple_new': tuple_new,
'__builtins__': {},
'__name__': f'namedtuple_{typename}',
}
code = f'lambda _cls, {arg_list}: _tuple_new(_cls, ({arg_list}))'
__new__ = eval(code, namespace)
__new__.__name__ = '__new__'
__new__.__doc__ = f'Create new instance of {typename}({arg_list})'
if defaults is not None:
__new__.__defaults__ = defaults
@classmethod
def _make(cls, iterable):
result = tuple_new(cls, iterable)
if _len(result) != num_fields:
raise TypeError(f'Expected {num_fields} arguments, got {len(result)}')
return result
_make.__func__.__doc__ = (f'Make a new {typename} object from a sequence '
'or iterable')
def _replace(self, /, **kwds):
result = self._make(_map(kwds.pop, field_names, self))
if kwds:
raise ValueError(f'Got unexpected field names: {list(kwds)!r}')
return result
_replace.__doc__ = (f'Return a new {typename} object replacing specified '
'fields with new values')
def __repr__(self):
'Return a nicely formatted representation string'
return self.__class__.__name__ + repr_fmt % self
def _asdict(self):
'Return a new dict which maps field names to their values.'
return _dict(_zip(self._fields, self))
def __getnewargs__(self):
'Return self as a plain tuple. Used by copy and pickle.'
return _tuple(self)
# Modify function metadata to help with introspection and debugging
for method in (
__new__,
_make.__func__,
_replace,
__repr__,
_asdict,
__getnewargs__,
):
method.__qualname__ = f'{typename}.{method.__name__}'
# Build-up the class namespace dictionary
# and use type() to build the result class
class_namespace = {
'__doc__': f'{typename}({arg_list})',
'__slots__': (),
'_fields': field_names,
'_field_defaults': field_defaults,
'__new__': __new__,
'_make': _make,
'_replace': _replace,
'__repr__': __repr__,
'_asdict': _asdict,
'__getnewargs__': __getnewargs__,
'__match_args__': field_names,
}
for index, name in enumerate(field_names):
doc = _sys.intern(f'Alias for field number {index}')
class_namespace[name] = _tuplegetter(index, doc)
result = type(typename, (tuple,), class_namespace)
# For pickling to work, the __module__ variable needs to be set to the frame
# where the named tuple is created. Bypass this step in environments where
# sys._getframe is not defined (Jython for example) or sys._getframe is not
# defined for arguments greater than 0 (IronPython), or where the user has
# specified a particular module.
if module is None:
try:
module = _sys._getframe(1).f_globals.get('__name__', '__main__')
except (AttributeError, ValueError):
pass
if module is not None:
result.__module__ = module
return result
| (self, /, **kwds) |
21,746 | aiosocks.protocols | Socks4Protocol | null | class Socks4Protocol(BaseSocksProtocol):
def __init__(self, proxy, proxy_auth, dst, app_protocol_factory, waiter,
remote_resolve=True, loop=None, ssl=False,
server_hostname=None, negotiate_done_cb=None,
reader_limit=DEFAULT_LIMIT):
proxy_auth = proxy_auth or Socks4Auth('')
if not isinstance(proxy, Socks4Addr):
raise ValueError('Invalid proxy format')
if not isinstance(proxy_auth, Socks4Auth):
raise ValueError('Invalid proxy_auth format')
super().__init__(proxy, proxy_auth, dst, app_protocol_factory,
waiter, remote_resolve=remote_resolve, loop=loop,
ssl=ssl, server_hostname=server_hostname,
reader_limit=reader_limit,
negotiate_done_cb=negotiate_done_cb)
async def socks_request(self, cmd):
# prepare destination addr/port
host, port = self._dst_host, self._dst_port
port_bytes = struct.pack(b'>H', port)
include_hostname = False
try:
host_bytes = socket.inet_aton(host)
except socket.error:
if self._remote_resolve:
host_bytes = bytes([c.NULL, c.NULL, c.NULL, 0x01])
include_hostname = True
else:
# it's not an IP number, so it's probably a DNS name.
family, host = await self._get_dst_addr()
host_bytes = socket.inet_aton(host)
# build and send connect command
req = [c.SOCKS_VER4, cmd, port_bytes,
host_bytes, self._auth.login, c.NULL]
if include_hostname:
req += [self._dst_host.encode('idna'), c.NULL]
self.write_request(req)
# read/process result
resp = await self.read_response(8)
if resp[0] != c.NULL:
raise InvalidServerReply('SOCKS4 proxy server sent invalid data')
if resp[1] != c.SOCKS4_GRANTED:
error = c.SOCKS4_ERRORS.get(resp[1], 'Unknown error')
raise SocksError('[Errno {0:#04x}]: {1}'.format(resp[1], error))
binded = socket.inet_ntoa(resp[4:]), struct.unpack('>H', resp[2:4])[0]
return (host, port), binded
| (proxy, proxy_auth, dst, app_protocol_factory, waiter, remote_resolve=True, loop=None, ssl=False, server_hostname=None, negotiate_done_cb=None, reader_limit=65536) |
21,747 | asyncio.streams | __del__ | null | def __del__(self):
# Prevent reports about unhandled exceptions.
# Better than self._closed._log_traceback = False hack
try:
closed = self._closed
except AttributeError:
pass # failed constructor
else:
if closed.done() and not closed.cancelled():
closed.exception()
| (self) |
21,748 | aiosocks.protocols | __init__ | null | def __init__(self, proxy, proxy_auth, dst, app_protocol_factory, waiter,
remote_resolve=True, loop=None, ssl=False,
server_hostname=None, negotiate_done_cb=None,
reader_limit=DEFAULT_LIMIT):
proxy_auth = proxy_auth or Socks4Auth('')
if not isinstance(proxy, Socks4Addr):
raise ValueError('Invalid proxy format')
if not isinstance(proxy_auth, Socks4Auth):
raise ValueError('Invalid proxy_auth format')
super().__init__(proxy, proxy_auth, dst, app_protocol_factory,
waiter, remote_resolve=remote_resolve, loop=loop,
ssl=ssl, server_hostname=server_hostname,
reader_limit=reader_limit,
negotiate_done_cb=negotiate_done_cb)
| (self, proxy, proxy_auth, dst, app_protocol_factory, waiter, remote_resolve=True, loop=None, ssl=False, server_hostname=None, negotiate_done_cb=None, reader_limit=65536) |
21,749 | asyncio.streams | _drain_helper | null | def connection_lost(self, exc):
self._connection_lost = True
# Wake up the writer(s) if currently paused.
if not self._paused:
return
for waiter in self._drain_waiters:
if not waiter.done():
if exc is None:
waiter.set_result(None)
else:
waiter.set_exception(exc)
| (self) |
21,750 | asyncio.streams | _get_close_waiter | null | def _get_close_waiter(self, stream):
return self._closed
| (self, stream) |
21,751 | aiosocks.protocols | _get_dst_addr | null | def write_request(self, request):
bdata = bytearray()
for item in request:
if isinstance(item, int):
bdata.append(item)
elif isinstance(item, (bytearray, bytes)):
bdata += item
else:
raise ValueError('Unsupported item')
self._stream_writer.write(bdata)
| (self) |
21,752 | aiosocks.protocols | connection_lost | null | def connection_lost(self, exc):
if self._negotiate_done and self._app_protocol is not self:
self._loop.call_soon(self._app_protocol.connection_lost, exc)
super().connection_lost(exc)
| (self, exc) |
21,753 | aiosocks.protocols | connection_made | null | def connection_made(self, transport):
# connection_made is called
if self._transport:
return
super().connection_made(transport)
self._transport = transport
| (self, transport) |
21,754 | aiosocks.protocols | data_received | null | def data_received(self, data):
if self._negotiate_done and self._app_protocol is not self:
self._app_protocol.data_received(data)
else:
super().data_received(data)
| (self, data) |
21,755 | aiosocks.protocols | eof_received | null | def eof_received(self):
if self._negotiate_done and self._app_protocol is not self:
self._app_protocol.eof_received()
super().eof_received()
| (self) |
21,756 | aiosocks.protocols | negotiate | null | def __init__(self, proxy, proxy_auth, dst, app_protocol_factory, waiter, *,
remote_resolve=True, loop=None, ssl=False,
server_hostname=None, negotiate_done_cb=None,
reader_limit=DEFAULT_LIMIT):
if not isinstance(dst, (tuple, list)) or len(dst) != 2:
raise ValueError(
'Invalid dst format, tuple("dst_host", dst_port))'
)
self._proxy = proxy
self._auth = proxy_auth
self._dst_host, self._dst_port = dst
self._remote_resolve = remote_resolve
self._waiter = waiter
self._ssl = ssl
self._server_hostname = server_hostname
self._negotiate_done_cb = negotiate_done_cb
self._loop = loop or asyncio.get_event_loop()
self._transport = None
self._negotiate_done = False
self._proxy_peername = None
self._proxy_sockname = None
if app_protocol_factory:
self._app_protocol = app_protocol_factory()
else:
self._app_protocol = self
reader = asyncio.StreamReader(loop=self._loop, limit=reader_limit)
super().__init__(stream_reader=reader,
client_connected_cb=self.negotiate, loop=self._loop)
| (self, reader, writer) |
21,757 | aiosocks.protocols | pause_writing | null | def pause_writing(self):
if self._negotiate_done and self._app_protocol is not self:
self._app_protocol.pause_writing()
else:
super().pause_writing()
| (self) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.