schuetz3/schuetz3-erpnext
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

style: format code with black

Browse Source
This commit is contained in:
Ankush Menat
2022-03-28 18:52:46 +05:30
parent 21e00da3d6
commit 494bd9ef78
1395 changed files with 91704 additions and 62532 deletions
Download Patch File Download Diff File Expand all files Collapse all files

191
erpnext/controllers/item_variant.py
View File

@@ -10,24 +10,30 @@ from frappe import _
from frappe.utils import cstr, flt
class ItemVariantExistsError(frappe.ValidationError): pass
class InvalidItemAttributeValueError(frappe.ValidationError): pass
class ItemTemplateCannotHaveStock(frappe.ValidationError): pass
class ItemVariantExistsError(frappe.ValidationError):
pass
class InvalidItemAttributeValueError(frappe.ValidationError):
pass
class ItemTemplateCannotHaveStock(frappe.ValidationError):
pass
@frappe.whitelist()
def get_variant(template, args=None, variant=None, manufacturer=None,
manufacturer_part_no=None):
def get_variant(template, args=None, variant=None, manufacturer=None, manufacturer_part_no=None):
"""Validates Attributes and their Values, then looks for an exactly
matching Item Variant
matching Item Variant
:param item: Template Item
:param args: A dictionary with "Attribute" as key and "Attribute Value" as value
:param item: Template Item
:param args: A dictionary with "Attribute" as key and "Attribute Value" as value
"""
item_template = frappe.get_doc('Item', template)
item_template = frappe.get_doc("Item", template)
if item_template.variant_based_on=='Manufacturer' and manufacturer:
return make_variant_based_on_manufacturer(item_template, manufacturer,
manufacturer_part_no)
if item_template.variant_based_on == "Manufacturer" and manufacturer:
return make_variant_based_on_manufacturer(item_template, manufacturer, manufacturer_part_no)
else:
if isinstance(args, str):
args = json.loads(args)
@@ -36,28 +42,30 @@ def get_variant(template, args=None, variant=None, manufacturer=None,
frappe.throw(_("Please specify at least one attribute in the Attributes table"))
return find_variant(template, args, variant)
def make_variant_based_on_manufacturer(template, manufacturer, manufacturer_part_no):
'''Make and return a new variant based on manufacturer and
manufacturer part no'''
"""Make and return a new variant based on manufacturer and
manufacturer part no"""
from frappe.model.naming import append_number_if_name_exists
variant = frappe.new_doc('Item')
variant = frappe.new_doc("Item")
copy_attributes_to_variant(template, variant)
variant.manufacturer = manufacturer
variant.manufacturer_part_no = manufacturer_part_no
variant.item_code = append_number_if_name_exists('Item', template.name)
variant.item_code = append_number_if_name_exists("Item", template.name)
return variant
def validate_item_variant_attributes(item, args=None):
if isinstance(item, str):
item = frappe.get_doc('Item', item)
item = frappe.get_doc("Item", item)
if not args:
args = {d.attribute.lower():d.attribute_value for d in item.attributes}
args = {d.attribute.lower(): d.attribute_value for d in item.attributes}
attribute_values, numeric_values = get_attribute_values(item)
@@ -73,6 +81,7 @@ def validate_item_variant_attributes(item, args=None):
attributes_list = attribute_values.get(attribute.lower(), [])
validate_item_attribute_value(attributes_list, attribute, value, item.name, from_variant=True)
def validate_is_incremental(numeric_attribute, attribute, value, item):
from_range = numeric_attribute.from_range
to_range = numeric_attribute.to_range
@@ -84,30 +93,48 @@ def validate_is_incremental(numeric_attribute, attribute, value, item):
is_in_range = from_range <= flt(value) <= to_range
precision = max(len(cstr(v).split(".")[-1].rstrip("0")) for v in (value, increment))
#avoid precision error by rounding the remainder
# avoid precision error by rounding the remainder
remainder = flt((flt(value) - from_range) % increment, precision)
is_incremental = remainder==0 or remainder==increment
is_incremental = remainder == 0 or remainder == increment
if not (is_in_range and is_incremental):
frappe.throw(_("Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4}")\
.format(attribute, from_range, to_range, increment, item),
InvalidItemAttributeValueError, title=_('Invalid Attribute'))
frappe.throw(
_(
"Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4}"
).format(attribute, from_range, to_range, increment, item),
InvalidItemAttributeValueError,
title=_("Invalid Attribute"),
)
def validate_item_attribute_value(attributes_list, attribute, attribute_value, item, from_variant=True):
allow_rename_attribute_value = frappe.db.get_single_value('Item Variant Settings', 'allow_rename_attribute_value')
def validate_item_attribute_value(
attributes_list, attribute, attribute_value, item, from_variant=True
):
allow_rename_attribute_value = frappe.db.get_single_value(
"Item Variant Settings", "allow_rename_attribute_value"
)
if allow_rename_attribute_value:
pass
elif attribute_value not in attributes_list:
if from_variant:
frappe.throw(_("{0} is not a valid Value for Attribute {1} of Item {2}.").format(
frappe.bold(attribute_value), frappe.bold(attribute), frappe.bold(item)), InvalidItemAttributeValueError, title=_("Invalid Value"))
frappe.throw(
_("{0} is not a valid Value for Attribute {1} of Item {2}.").format(
frappe.bold(attribute_value), frappe.bold(attribute), frappe.bold(item)
),
InvalidItemAttributeValueError,
title=_("Invalid Value"),
)
else:
msg = _("The value {0} is already assigned to an existing Item {1}.").format(
frappe.bold(attribute_value), frappe.bold(item))
msg += "<br>" + _("To still proceed with editing this Attribute Value, enable {0} in Item Variant Settings.").format(frappe.bold("Allow Rename Attribute Value"))
frappe.bold(attribute_value), frappe.bold(item)
)
msg += "<br>" + _(
"To still proceed with editing this Attribute Value, enable {0} in Item Variant Settings."
).format(frappe.bold("Allow Rename Attribute Value"))
frappe.throw(msg, InvalidItemAttributeValueError, title=_("Edit Not Allowed"))
frappe.throw(msg, InvalidItemAttributeValueError, title=_('Edit Not Allowed'))
def get_attribute_values(item):
if not frappe.flags.attribute_values:
@@ -116,9 +143,11 @@ def get_attribute_values(item):
for t in frappe.get_all("Item Attribute Value", fields=["parent", "attribute_value"]):
attribute_values.setdefault(t.parent.lower(), []).append(t.attribute_value)
for t in frappe.get_all('Item Variant Attribute',
for t in frappe.get_all(
"Item Variant Attribute",
fields=["attribute", "from_range", "to_range", "increment"],
filters={'numeric_values': 1, 'parent': item.variant_of}):
filters={"numeric_values": 1, "parent": item.variant_of},
):
numeric_values[t.attribute.lower()] = t
frappe.flags.attribute_values = attribute_values
@@ -126,14 +155,22 @@ def get_attribute_values(item):
return frappe.flags.attribute_values, frappe.flags.numeric_values
def find_variant(template, args, variant_item_code=None):
conditions = ["""(iv_attribute.attribute={0} and iv_attribute.attribute_value={1})"""\
.format(frappe.db.escape(key), frappe.db.escape(cstr(value))) for key, value in args.items()]
conditions = [
"""(iv_attribute.attribute={0} and iv_attribute.attribute_value={1})""".format(
frappe.db.escape(key), frappe.db.escape(cstr(value))
)
for key, value in args.items()
]
conditions = " or ".join(conditions)
from erpnext.e_commerce.variant_selector.utils import get_item_codes_by_attributes
possible_variants = [i for i in get_item_codes_by_attributes(args, template) if i != variant_item_code]
possible_variants = [
i for i in get_item_codes_by_attributes(args, template) if i != variant_item_code
]
for variant in possible_variants:
variant = frappe.get_doc("Item", variant)
@@ -145,7 +182,7 @@ def find_variant(template, args, variant_item_code=None):
for attribute, value in args.items():
for row in variant.attributes:
if row.attribute==attribute and row.attribute_value== cstr(value):
if row.attribute == attribute and row.attribute_value == cstr(value):
# this row matches
match_count += 1
break
@@ -153,6 +190,7 @@ def find_variant(template, args, variant_item_code=None):
if match_count == len(args.keys()):
return variant.name
@frappe.whitelist()
def create_variant(item, args):
if isinstance(args, str):
@@ -160,14 +198,11 @@ def create_variant(item, args):
template = frappe.get_doc("Item", item)
variant = frappe.new_doc("Item")
variant.variant_based_on = 'Item Attribute'
variant.variant_based_on = "Item Attribute"
variant_attributes = []
for d in template.attributes:
variant_attributes.append({
"attribute": d.attribute,
"attribute_value": args.get(d.attribute)
})
variant_attributes.append({"attribute": d.attribute, "attribute_value": args.get(d.attribute)})
variant.set("attributes", variant_attributes)
copy_attributes_to_variant(template, variant)
@@ -175,6 +210,7 @@ def create_variant(item, args):
return variant
@frappe.whitelist()
def enqueue_multiple_variant_creation(item, args):
# There can be innumerable attribute combinations, enqueue
@@ -189,9 +225,14 @@ def enqueue_multiple_variant_creation(item, args):
if total_variants < 10:
return create_multiple_variants(item, args)
else:
frappe.enqueue("erpnext.controllers.item_variant.create_multiple_variants",
item=item, args=args, now=frappe.flags.in_test);
return 'queued'
frappe.enqueue(
"erpnext.controllers.item_variant.create_multiple_variants",
item=item,
args=args,
now=frappe.flags.in_test,
)
return "queued"
def create_multiple_variants(item, args):
count = 0
@@ -204,26 +245,27 @@ def create_multiple_variants(item, args):
if not get_variant(item, args=attribute_values):
variant = create_variant(item, attribute_values)
variant.save()
count +=1
count += 1
return count
def generate_keyed_value_combinations(args):
"""
From this:
args = {"attr1": ["a", "b", "c"], "attr2": ["1", "2"], "attr3": ["A"]}
args = {"attr1": ["a", "b", "c"], "attr2": ["1", "2"], "attr3": ["A"]}
To this:
[
{u'attr1': u'a', u'attr2': u'1', u'attr3': u'A'},
{u'attr1': u'b', u'attr2': u'1', u'attr3': u'A'},
{u'attr1': u'c', u'attr2': u'1', u'attr3': u'A'},
{u'attr1': u'a', u'attr2': u'2', u'attr3': u'A'},
{u'attr1': u'b', u'attr2': u'2', u'attr3': u'A'},
{u'attr1': u'c', u'attr2': u'2', u'attr3': u'A'}
]
[
{u'attr1': u'a', u'attr2': u'1', u'attr3': u'A'},
{u'attr1': u'b', u'attr2': u'1', u'attr3': u'A'},
{u'attr1': u'c', u'attr2': u'1', u'attr3': u'A'},
{u'attr1': u'a', u'attr2': u'2', u'attr3': u'A'},
{u'attr1': u'b', u'attr2': u'2', u'attr3': u'A'},
{u'attr1': u'c', u'attr2': u'2', u'attr3': u'A'}
]
"""
# Return empty list if empty
@@ -259,17 +301,25 @@ def generate_keyed_value_combinations(args):
return results
def copy_attributes_to_variant(item, variant):
# copy non no-copy fields
exclude_fields = ["naming_series", "item_code", "item_name", "published_in_website",
"opening_stock", "variant_of", "valuation_rate"]
exclude_fields = [
"naming_series",
"item_code",
"item_name",
"published_in_website",
"opening_stock",
"variant_of",
"valuation_rate",
]
if item.variant_based_on=='Manufacturer':
if item.variant_based_on == "Manufacturer":
# don't copy manufacturer values if based on part no
exclude_fields += ['manufacturer', 'manufacturer_part_no']
exclude_fields += ["manufacturer", "manufacturer_part_no"]
allow_fields = [d.field_name for d in frappe.get_all("Variant Field", fields = ['field_name'])]
allow_fields = [d.field_name for d in frappe.get_all("Variant Field", fields=["field_name"])]
if "variant_based_on" not in allow_fields:
allow_fields.append("variant_based_on")
for field in item.meta.fields:
@@ -288,11 +338,11 @@ def copy_attributes_to_variant(item, variant):
variant.variant_of = item.name
if 'description' not in allow_fields:
if "description" not in allow_fields:
if not variant.description:
variant.description = ""
variant.description = ""
else:
if item.variant_based_on=='Item Attribute':
if item.variant_based_on == "Item Attribute":
if variant.attributes:
attributes_description = item.description + " "
for d in variant.attributes:
@@ -301,6 +351,7 @@ def copy_attributes_to_variant(item, variant):
if attributes_description not in variant.description:
variant.description = attributes_description
def make_variant_item_code(template_item_code, template_item_name, variant):
"""Uses template's item code and abbreviations to make variant's item code"""
if variant.item_code:
@@ -308,13 +359,14 @@ def make_variant_item_code(template_item_code, template_item_name, variant):
abbreviations = []
for attr in variant.attributes:
item_attribute = frappe.db.sql("""select i.numeric_values, v.abbr
item_attribute = frappe.db.sql(
"""select i.numeric_values, v.abbr
from `tabItem Attribute` i left join `tabItem Attribute Value` v
on (i.name=v.parent)
where i.name=%(attribute)s and (v.attribute_value=%(attribute_value)s or i.numeric_values = 1)""", {
"attribute": attr.attribute,
"attribute_value": attr.attribute_value
}, as_dict=True)
where i.name=%(attribute)s and (v.attribute_value=%(attribute_value)s or i.numeric_values = 1)""",
{"attribute": attr.attribute, "attribute_value": attr.attribute_value},
as_dict=True,
)
if not item_attribute:
continue
@@ -322,13 +374,16 @@ def make_variant_item_code(template_item_code, template_item_name, variant):
# frappe.bold(attr.attribute_value)), title=_('Invalid Attribute'),
# exc=InvalidItemAttributeValueError)
abbr_or_value = cstr(attr.attribute_value) if item_attribute[0].numeric_values else item_attribute[0].abbr
abbr_or_value = (
cstr(attr.attribute_value) if item_attribute[0].numeric_values else item_attribute[0].abbr
)
abbreviations.append(abbr_or_value)
if abbreviations:
variant.item_code = "{0}-{1}".format(template_item_code, "-".join(abbreviations))
variant.item_name = "{0}-{1}".format(template_item_name, "-".join(abbreviations))
@frappe.whitelist()
def create_variant_doc_for_quick_entry(template, args):
variant_based_on = frappe.db.get_value("Item", template, "variant_based_on")