nt25 0.1.0__tar.gz → 0.1.2__tar.gz

{nt25-0.1.0 → nt25-0.1.2}/.editorconfig

@@ -1,10 +1,10 @@
-root = true
-
-[*]
-indent_style = space
-indent_size = 2
-insert_final_newline = true
-trim_trailing_whitespace = true
-end_of_line = lf
-charset = utf-8
-max_line_length = 88
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+insert_final_newline = true
+trim_trailing_whitespace = true
+end_of_line = lf
+charset = utf-8
+max_line_length = 88

{nt25-0.1.0 → nt25-0.1.2}/.flake8

@@ -1,2 +1,2 @@
-[flake8]
-indent-size = 2
+[flake8]
+indent-size = 2

{nt25-0.1.0 → nt25-0.1.2}/.github/workflows/publish.yml

@@ -1,29 +1,29 @@
-name: Publish
-
-on:
-  push:
-    tags: ["*"]
-
-jobs:
-  pypi-publish:
-    runs-on: ubuntu-latest
-
-    permissions:
-      id-token: write
-
-    environment:
-      name: publish
-      url: https://pypi.org/p/ntpy
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup
-        uses: astral-sh/setup-uv@v6
-
-      - name: Build
-        run: uv build
-
-      - name: Publish
-        uses: pypa/gh-action-pypi-publish@release/v1
+name: Publish
+
+on:
+  push:
+    tags: ["*"]
+
+jobs:
+  pypi-publish:
+    runs-on: ubuntu-latest
+
+    permissions:
+      id-token: write
+
+    environment:
+      name: publish
+      url: https://pypi.org/p/nt25
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup
+        uses: astral-sh/setup-uv@v6
+
+      - name: Build
+        run: uv build
+
+      - name: Publish
+        uses: pypa/gh-action-pypi-publish@release/v1

{nt25-0.1.0 → nt25-0.1.2}/.gitignore

@@ -10,6 +10,12 @@ wheels/
 uv.lock
 .venv
 
+# package
+*.spec
+
+# dataset
 ds/
 *.csv
 *.xlsx
+
+

nt25-0.1.2/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "cSpell.words": ["bfunc"]
+}

{nt25-0.1.0 → nt25-0.1.2}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: nt25
-Version: 0.1.0
+Version: 0.1.2
 Summary: Neo's Tools of Python
-Requires-Python: >=3.13
+Requires-Python: >=3.10
 Requires-Dist: matplotlib>=3.10.6
 Requires-Dist: openpyxl>=3.1.5
 Requires-Dist: pandas>=2.3.2
@@ -10,15 +10,19 @@ Requires-Dist: scikit-learn>=1.7.1
 Requires-Dist: sympy>=1.14.0
 Description-Content-Type: text/markdown
 
-# NT.py
+# nt25.py
 
-Neo's Tools of Python
+Neo's Tools of Python in 2025
 
 ## plans
 
 - [x] fio
 - [x] calc
-- [ ] draw with 3d
+- [x] draw
+- [ ] mysql
+- [ ] redis
+- [ ] maptrans
+- [ ] ttp
 
 ## scripts from init
 

{nt25-0.1.0 → nt25-0.1.2}/README.md

@@ -1,22 +1,26 @@
-# NT.py
-
-Neo's Tools of Python
-
-## plans
-
-- [x] fio
-- [x] calc
-- [ ] draw with 3d
-
-## scripts from init
-
-```sh
-uv init
-uv run ntpy
-```
-
-## fun
-
-$$
-\sqrt{-1},2^{3},\sum,\pi
-$$
+# nt25.py
+
+Neo's Tools of Python in 2025
+
+## plans
+
+- [x] fio
+- [x] calc
+- [x] draw
+- [ ] mysql
+- [ ] redis
+- [ ] maptrans
+- [ ] ttp
+
+## scripts from init
+
+```sh
+uv init
+uv run ntpy
+```
+
+## fun
+
+$$
+\sqrt{-1},2^{3},\sum,\pi
+$$

{nt25-0.1.0 → nt25-0.1.2}/pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "nt25"
-version = "0.1.0"
+version = "0.1.2"
 description = "Neo's Tools of Python"
 readme = "README.md"
-requires-python = ">=3.13"
+requires-python = ">=3.10"
 dependencies = [
     "matplotlib>=3.10.6",
     "openpyxl>=3.1.5",
@@ -13,7 +13,7 @@ dependencies = [
 ]
 
 [project.scripts]
-ntpy = "ntpy.main:main"
+nt25 = "nt25.main:main"
 
 [build-system]
 requires = ["hatchling"]

{nt25-0.1.0 → nt25-0.1.2}/src/nt25/__init__.py

@@ -1,7 +1,9 @@
-import importlib.metadata as meta
-
-from .lib import fio, calc, draw
-from .lib.draw import DType
-
-__version__ = meta.version(str(__package__))
-__all__ = ('__version__', 'fio', 'calc', 'draw', 'DType')
+import importlib.metadata as meta
+
+from .lib import fio, calc, draw
+from .lib.draw import DType
+
+__version__ = meta.version(str(__package__))
+__samples_path__ = __file__.replace('__init__.py', 'samples')
+
+__all__ = ('__version__', '__samples_path__', 'fio', 'calc', 'draw', 'DType')

{nt25-0.1.0 → nt25-0.1.2}/src/nt25/lib/calc.py

@@ -1,104 +1,104 @@
-import re
-from typing import Iterable
-import numpy as np
-
-from sympy import symbols, Eq, solve
-
-from sklearn.metrics import r2_score as r2
-from sklearn.linear_model import LinearRegression
-from sklearn.preprocessing import PolynomialFeatures
-
-
-def str2e(s) -> str:
-  return s if len(s) < 5 else f'{float(s):.4e}'
-
-
-def fl2el(fl) -> list[str]:
-  return list(map(lambda f: str2e(str(f)), fl))
-
-
-def poly(x, y, degree=2) -> Iterable:
-  return np.polyfit(x, y, degree).tolist()
-
-
-def polyResults(coef, x) -> Iterable:
-  return np.poly1d(coef)(x).tolist()
-
-
-def polyRoots(coef) -> Iterable:
-  return np.roots(coef).tolist()
-
-
-def xn2y(X, y, degree=2, output=False, foo='xn2y'):
-  poly = PolynomialFeatures(degree=degree, include_bias=False)
-
-  Xa = np.array(X)
-  if len(Xa.shape) == 1:
-    Xa = np.array([X])
-
-  x = Xa.T
-  xp = poly.fit_transform(x)
-
-  model = LinearRegression()
-  model.fit(xp, y)
-  # y1 = model.predict(xp)
-
-  coef = model.coef_
-  names = poly.get_feature_names_out().tolist()
-
-  eq = f'{model.intercept_:.4e} + '
-  for i in range(len(names)):
-    ex = names[i].replace('^', '**').replace(' ', '*')
-    eq += f"({coef[i]:.4e})*{ex} + "
-
-  eq = re.sub(r'x(\d+)', r'x[\1]', eq[:-3])
-  func = _genFunc(foo, 'x', eq)
-
-  y2 = [func(x[i]) for i in range(len(x))]
-  yr2 = r2(y, y2)
-
-  if output:
-    q = eq.replace(' + ', ' + \\\n\t') \
-        .replace('*x', ' * x').replace('e+00', '')
-
-    print(f'{foo}: degree = {degree}, R² = {yr2:.4%}\n  y = {q}\n')
-
-  return {
-      'func': func,
-      'r2': yr2,
-      'eq': eq,
-  }
-
-
-def _genFunc(name, args, expr):
-  local = {}
-  src = compile(f'def {name}({args}):\n\treturn {expr}', "<string>", "exec")
-  exec(src, {}, local)
-  return local[name]
-
-
-def solveEq(eq, output=False, foo='solve'):
-  (x0, x1, y) = symbols('x:2,y')
-  eq = re.sub(r'x\[(\d+)\]', r'x\1', eq)
-  solution = solve(Eq(eval(eq), y), x0)
-
-  real = []
-  for s in solution:
-    sol = str(s)
-    if 'I' in sol:
-      continue
-
-    func = _genFunc(foo, 'y, x1=0', sol)
-    s4e = re.sub(r'([-]?\d*\.\d+)', lambda m: str2e(m.group(0)), sol)
-
-    if output:
-      print(f'{foo}: {eq}\n  x0 = {s4e}\n')
-
-    real.append({
-        'org': eq,
-        'func': func,
-        'eq': sol,
-        'eq.4e': s4e,
-    })
-
-  return real
+import re
+from typing import Iterable
+import numpy as np
+
+from sympy import symbols, Eq, solve
+
+from sklearn.metrics import r2_score as r2
+from sklearn.linear_model import LinearRegression
+from sklearn.preprocessing import PolynomialFeatures
+
+
+def str2e(s) -> str:
+  return s if len(s) < 5 else f'{float(s):.4e}'
+
+
+def fl2el(fl) -> list[str]:
+  return list(map(lambda f: str2e(str(f)), fl))
+
+
+def poly(x, y, degree=2) -> Iterable:
+  return np.polyfit(x, y, degree).tolist()
+
+
+def polyResults(coef, x) -> Iterable:
+  return np.poly1d(coef)(x).tolist()
+
+
+def polyRoots(coef) -> Iterable:
+  return np.roots(coef).tolist()
+
+
+def xn2y(X, y, degree=2, output=False, foo='xn2y'):
+  poly = PolynomialFeatures(degree=degree, include_bias=False)
+
+  Xa = np.array(X)
+  if len(Xa.shape) == 1:
+    Xa = np.array([X])
+
+  x = Xa.T
+  xp = poly.fit_transform(x)
+
+  model = LinearRegression()
+  model.fit(xp, y)
+  # y1 = model.predict(xp)
+
+  coef = model.coef_
+  names = poly.get_feature_names_out().tolist()
+
+  eq = f'{model.intercept_:.4e} + '
+  for i in range(len(names)):
+    ex = names[i].replace('^', '**').replace(' ', '*')
+    eq += f"({coef[i]:.4e})*{ex} + "
+
+  eq = re.sub(r'x(\d+)', r'x[\1]', eq[:-3])
+  func = _genFunc(foo, 'x', eq)
+
+  y2 = [func(x[i]) for i in range(len(x))]
+  yr2 = r2(y, y2)
+
+  if output:
+    q = eq.replace(' + ', ' + \\\n\t') \
+        .replace('*x', ' * x').replace('e+00', '')
+
+    print(f'{foo}: degree = {degree}, R² = {yr2:.4%}\n  y = {q}\n')
+
+  return {
+      'func': func,
+      'r2': yr2,
+      'eq': eq,
+  }
+
+
+def _genFunc(name, args, expr):
+  local = {}
+  src = compile(f'def {name}({args}):\n\treturn {expr}', "<string>", "exec")
+  exec(src, {}, local)
+  return local[name]
+
+
+def solveEq(eq, output=False, foo='solve'):
+  (x0, x1, y) = symbols('x:2,y')
+  eq = re.sub(r'x\[(\d+)\]', r'x\1', eq)
+  solution = solve(Eq(eval(eq), y), x0)
+
+  real = []
+  for s in solution:
+    sol = str(s)
+    if 'I' in sol:
+      continue
+
+    func = _genFunc(foo, 'y, x1=0', sol.replace('y', 'y[0]'))
+    s4e = re.sub(r'([-]?\d*\.\d+)', lambda m: str2e(m.group(0)), sol)
+
+    if output:
+      print(f'{foo}: {eq}\n  x0 = {s4e}\n')
+
+    real.append({
+        'org': eq,
+        'func': func,
+        'eq': sol,
+        'eq.4e': s4e,
+    })
+
+  return real

nt25-0.1.2/src/nt25/lib/draw.py

@@ -0,0 +1,276 @@
+from enum import Enum
+from random import sample
+
+import numpy as np
+
+from matplotlib import pyplot as plot
+from matplotlib.axes import Axes
+from mpl_toolkits.mplot3d import Axes3D
+
+from . import calc
+
+# import matplotlib.animation as animation
+
+
+FONTS = [
+    'Microsoft YaHei',
+    'PingFang SC',
+    'Arial Unicode MS',
+    'Noto Sans CJK SC',
+    'Arial'
+]
+
+COLORS = ['blue', 'red', 'orange', 'black', 'pink']
+
+REFS = []
+
+
+class DType(Enum):
+  dot = 1,
+  line = 2,
+  func = 3,
+  dot3d = 4,
+  wireframe = 5,
+  surface = 6,
+
+
+def onClose(event):
+  global REFS
+
+  for r in REFS:
+    del r['figure']
+    del r['subplot']
+
+  REFS.clear()
+
+
+def _getPlot(ref, pos, is3D):
+  # def _getPlot(ref, pos, is3D) -> Axes | Axes3D:
+  global REFS
+
+  if 'figure' not in ref:
+    fig = plot.figure()
+    fig.canvas.mpl_connect('close_event', onClose)
+
+    plot.rcParams['font.sans-serif'] = FONTS
+    plot.rcParams['axes.unicode_minus'] = False
+
+    ref['figure'] = fig
+    REFS.append(ref)
+
+  if 'subplot' not in ref:
+    ref['subplot'] = {}
+
+  fig = ref['figure']
+  sub = ref['subplot']
+
+  if pos not in sub:
+    sub[pos] = fig.add_subplot(
+        pos, projection='3d') if is3D else fig.add_subplot(pos)
+
+  return sub[pos]
+
+
+def _genList(refer: list, length, random=False):
+  r = []
+
+  while len(r) < length:
+    r += sample(refer, len(refer)) if random else refer
+
+  return r[:length]
+
+
+def _genParam(pIn, pDefault, count):
+  if pIn is None:
+    pIn = pDefault
+
+  if count == 1:
+    if isinstance(pIn, (list, tuple)):
+      pIn = pIn[0]
+
+  elif len(pIn) != count:
+    # print(f"bad len {len(pIn)} != {count}")
+    pIn = None
+
+  return pIn
+
+
+def title(ref, title, pos=111, x=None, y=None, z=None):
+  result = False
+
+  if 'subplot' in ref:
+    sub = ref['subplot']
+
+    if pos in sub:
+      result = True
+      sub[pos].set_title(title)
+
+      if x:
+        sub[pos].set_xlabel(x)
+
+      if y:
+        sub[pos].set_ylabel(y)
+
+      if z:
+        sub[pos].set_zlabel(z)
+
+  return result
+
+
+def _gen3DXY(X, Y, extend=0.2):
+  dx = (max(X) - min(X)) * extend
+  d0 = np.linspace(min(X) - dx, max(X) + dx)
+
+  dy = (max(Y) - min(Y)) * extend
+  d1 = np.linspace(min(Y) - dy, max(Y) + dy)
+
+  return np.meshgrid(d0, d1)
+
+
+def draw(type=DType.dot, X=None, Y=None, Z=None, Func=None, min=None, max=None,
+         ref=None, pos=None, label=None, color=None, randomColor=False,
+         labelLocation='upper left', *args, **kwargs):
+
+  if ref is None:
+    ref = {}
+
+  is3D = False
+  method = Axes.scatter
+
+  match type:
+    case DType.line:
+      method = Axes.plot
+
+    case DType.func:
+      method = Axes.plot
+
+      if Func is not None and min is not None and max is not None:
+        if callable(Func):
+          Func = (Func,)
+
+        X = []
+        Y = []
+
+        for i in range(len(Func)):
+          dx = np.linspace(min[i] if isinstance(min, (list, tuple)) else min,
+                           max[i] if isinstance(max, (list, tuple)) else max)
+
+          X.append(dx)
+          Y.append([Func[i]([x]) for x in dx])
+
+    case DType.dot3d:
+      is3D = True
+      method = Axes3D.scatter
+
+    case DType.wireframe:
+      is3D = True
+      # rstride=2, cstride=2
+      method = Axes3D.plot_wireframe
+
+    case DType.surface:
+      is3D = True
+      # cmap='Pastel2_r', antialiased=True
+      method = Axes3D.plot_surface
+
+  if X is None or Y is None:
+    print("no X/Y to draw")
+    return
+
+  Xa = np.array(X)
+  Ya = np.array(Y)
+
+  if Xa.shape != Ya.shape:
+    print(f"bad shape {Xa.shape} != {Ya.shape}")
+    return
+
+  if type == DType.dot3d:
+    if Z is None:
+      print("Z cannot be None")
+      return
+
+    Za = np.array(Z)
+    if Xa.shape != Za.shape:
+      print(f"bad shape {Xa.shape} == {Ya.shape} != {Za.shape}")
+      return
+
+  elif is3D:
+    if Z is not None and Func is None:
+      Za = np.array(Z)
+      if Xa.shape != Za.shape:
+        print(f"bad shape {Xa.shape} == {Ya.shape} != {Za.shape}")
+        return
+
+      F = calc.xn2y([X, Y], Z, degree=3)
+      Func = F['func']
+
+    if Func is None:
+      print("Func cannot be None")
+      return
+
+    if callable(Func):
+      X, Y = _gen3DXY(X, Y)
+      Z = Func([X, Y])
+    else:
+      print("Func need callable")
+      return
+
+  count = 1
+  # count = Xa.shape[0] if len(Xa.shape) > 1 else 1
+
+  if len(Xa.shape) > 1:
+    count = Xa.shape[0]
+    if count == 1:
+      X = X[0]
+      Y = Y[0]
+
+      if Z is not None and isinstance(Z, list):
+        Z = Z[0]
+
+  if is3D and type != DType.dot3d:
+    count = 1
+
+  pos = _genParam(pos, [111] * count, count)
+  label = _genParam(label, [None] * count, count)
+  color = _genParam(color, _genList(COLORS, count, random=randomColor), count)
+
+  if pos is None or color is None:
+    print("bad length")
+    return
+
+  if count == 1:
+    p = _getPlot(ref, pos, is3D)
+    _draw(method, p, type, X, Y, Z, label=label, color=color, *args, **kwargs)
+
+  elif (isinstance(pos, list) and
+        isinstance(label, list) and isinstance(color, list)):
+
+    for i in range(count):
+      p = _getPlot(ref, pos[i], is3D)
+      _draw(method, p, type, X[i], Y[i], Z[i]
+            if isinstance(Z, list) else None, label, color, *args, **kwargs)
+
+  if label is not None:
+    plot.legend(loc=labelLocation)
+
+  return ref
+
+
+def _draw(method, p, type, x, y, z, label, color, *args, **kwargs):
+  match type:
+    case DType.dot3d | DType.wireframe:
+      method(p, x, y, z, label=label, color=color,
+             antialiased=True, *args, **kwargs)
+
+    case DType.surface:
+      method(p, x, y, z, label=label, antialiased=True, *args, **kwargs)
+
+    case _:
+      method(p, x, y, label=label, color=color, *args, **kwargs)
+
+
+def show():
+  plot.show()
+
+
+def clear():
+  plot.clf()

{nt25-0.1.0 → nt25-0.1.2}/src/nt25/lib/fio.py

@@ -1,116 +1,116 @@
-import os
-import csv
-from typing import Iterable
-
-# import openpyxl
-import pandas as pd
-
-ENCODINGS = ['utf-8', 'utf-8-sig', 'gbk']
-
-
-def _switchEnc(foo, encoding=None, *args, **kwargs):
-  result = None
-
-  if encoding is None:
-    for enc in ENCODINGS if os.name != 'nt' else reversed(ENCODINGS):
-      try:
-        result = foo(encoding=enc, *args, **kwargs)
-        break
-      except Exception as e:
-        print(e)
-
-  else:
-    result = foo(encoding=encoding, *args, **kwargs)
-
-  return result
-
-
-def _getCSV(file, width, startLine, startCol, encoding):
-  f = open(file, encoding=encoding)
-  cf = csv.reader(f)
-
-  count = 0
-  result = [[] for _ in range(width - startCol)]
-
-  for line in cf:
-    if count >= startLine:
-      maxWidth = len(line)
-      for i in range(startCol, width):
-        x = line[i].strip() if maxWidth > i else ''
-
-        try:
-          result[i - startCol].append(float(x))
-        except ValueError:
-          result[i - startCol].append(x)
-
-    count += 1
-
-  f.close()
-  return result
-
-
-def _getCSV2(file, encoding=None, colsInline=True):
-  df = pd.read_csv(file, encoding=encoding)
-
-  row = df.to_numpy()
-  r = row.T if colsInline else row
-
-  return r.tolist()
-
-
-def getCSV(file, width=2, startLine=1, startCol=0, encoding=None):
-  return _switchEnc(foo=_getCSV, encoding=encoding, file=file,
-                    width=width, startLine=startLine, startCol=startCol)
-
-
-def getCSV2(file, encoding=None):
-  return _switchEnc(foo=_getCSV2, encoding=encoding, file=file)
-
-
-def saveCSV(data, file, encoding=None, colsInline=True):
-  if encoding is None:
-    encoding = 'utf-8'
-
-  with open(file, 'w', newline='', encoding=encoding) as f:
-    content = []
-
-    for d in data:
-      if isinstance(d, str):
-        content.append(data[d])
-      elif isinstance(d, Iterable):
-        content.append(d)
-
-    if colsInline:
-      content = list(map(list, zip(*content)))
-
-    cf = csv.writer(f)
-    cf.writerows(content)
-
-
-def saveCSV2(data, file, encoding=None, float_format=None, colsInline=True):
-  if data is not None:
-    df = pd.DataFrame(data)
-
-    if colsInline:
-      df = df.T
-
-    df.to_csv(file, index=False, encoding=encoding, float_format=float_format)
-
-
-def getXlsx(file, sheet=0, colsInLine=True):
-  df = pd.read_excel(file, sheet_name=sheet)
-
-  row = df.to_numpy()
-  r = row.T if colsInLine else row
-
-  return r.tolist()
-
-
-def saveXlsx(data, file, colsInline=True):
-  if data is not None:
-    df = pd.DataFrame(data)
-
-    if colsInline:
-      df = df.T
-
-    df.to_excel(file, index=False)
+import os
+import csv
+from typing import Iterable
+
+# import openpyxl
+import pandas as pd
+
+ENCODINGS = ['utf-8', 'utf-8-sig', 'gbk']
+
+
+def _switchEnc(foo, encoding=None, *args, **kwargs):
+  result = None
+
+  if encoding is None:
+    for enc in ENCODINGS if os.name != 'nt' else reversed(ENCODINGS):
+      try:
+        result = foo(encoding=enc, *args, **kwargs)
+        break
+      except Exception as e:
+        print(e)
+
+  else:
+    result = foo(encoding=encoding, *args, **kwargs)
+
+  return result
+
+
+def _getCSV(file, width, startLine, startCol, encoding):
+  f = open(file, encoding=encoding)
+  cf = csv.reader(f)
+
+  count = 0
+  result = [[] for _ in range(width - startCol)]
+
+  for line in cf:
+    if count >= startLine:
+      maxWidth = len(line)
+      for i in range(startCol, width):
+        x = line[i].strip() if maxWidth > i else ''
+
+        try:
+          result[i - startCol].append(float(x))
+        except ValueError:
+          result[i - startCol].append(x)
+
+    count += 1
+
+  f.close()
+  return result
+
+
+def _getCSV2(file, encoding=None, colsInline=True):
+  df = pd.read_csv(file, encoding=encoding)
+
+  row = df.to_numpy()
+  r = row.T if colsInline else row
+
+  return r.tolist()
+
+
+def getCSV(file, width=2, startLine=1, startCol=0, encoding=None):
+  return _switchEnc(foo=_getCSV, encoding=encoding, file=file,
+                    width=width, startLine=startLine, startCol=startCol)
+
+
+def getCSV2(file, encoding=None):
+  return _switchEnc(foo=_getCSV2, encoding=encoding, file=file)
+
+
+def saveCSV(data, file, encoding=None, colsInline=True):
+  if encoding is None:
+    encoding = 'utf-8'
+
+  with open(file, 'w', newline='', encoding=encoding) as f:
+    content = []
+
+    for d in data:
+      if isinstance(d, str):
+        content.append(data[d])
+      elif isinstance(d, Iterable):
+        content.append(d)
+
+    if colsInline:
+      content = list(map(list, zip(*content)))
+
+    cf = csv.writer(f)
+    cf.writerows(content)
+
+
+def saveCSV2(data, file, encoding=None, float_format=None, colsInline=True):
+  if data is not None:
+    df = pd.DataFrame(data)
+
+    if colsInline:
+      df = df.T
+
+    df.to_csv(file, index=False, encoding=encoding, float_format=float_format)
+
+
+def getXlsx(file, sheet=0, colsInLine=True):
+  df = pd.read_excel(file, sheet_name=sheet)
+
+  row = df.to_numpy()
+  r = row.T if colsInLine else row
+
+  return r.tolist()
+
+
+def saveXlsx(data, file, colsInline=True):
+  if data is not None:
+    df = pd.DataFrame(data)
+
+    if colsInline:
+      df = df.T
+
+    df.to_excel(file, index=False)

nt25-0.1.2/src/nt25/main.py

@@ -0,0 +1,74 @@
+from nt25 import fio, calc, draw, DType, __version__, __samples_path__
+
+# import timeit
+# timeit.timeit('', number=100, globals=globals())
+
+
+def main():
+  print(f"Hello from {__package__}({__version__})! ")
+
+  # [Neo] some file I/O: csv, xlsx
+  fio.saveCSV({
+      'Name': ['Alice', 'Bob', 'Charlie'],
+      'Age': [25.2, 30, 35],
+      'City': ['New York', 'Los Angeles', 'Chicago']
+  }, "out.csv", colsInline=False)
+
+  data = fio.getXlsx(__samples_path__ + '/test.xlsx')
+  fio.saveCSV(data, "out2.csv")
+
+  h = data[0]
+  s = data[1]
+  v = data[2]
+
+  # [Neo] some poly calculates
+  c = calc.poly(h, v)
+  ce = calc.fl2el(c)
+  print(c, ce)
+
+  foo = calc.xn2y(h, v, degree=3, output=True)
+  bar = calc.solveEq(foo['eq'], output=False)
+
+  func = foo['func']
+  bfunc = bar[0]['func']
+
+  Y = range(1000, 2000, 200)
+  X = [bfunc([y]) for y in Y]
+
+  # [Neo] draw with title, data dots
+  ref = draw.draw(X=h, Y=v)
+  draw.title(ref, "title", x='xlabel', y='ylabel')
+  draw.draw(type=DType.dot, X=X, Y=Y, ref=ref, color='red', s=120)
+  draw.show()
+
+  # [Neo] draw with function, split in two
+  draw.draw(type=DType.func, Func=func, min=40, max=60, ref=ref, pos=121,
+            label='func', color='red')
+  draw.draw(type=DType.func, Func=bfunc, min=0, max=4000, ref=ref, pos=122,
+            label='bfunc', labelLocation='upper right')
+  draw.show()
+
+  # [Neo] draw with 3d dots, and function in surface
+  ref = draw.draw(DType.dot3d, X=h, Y=s, Z=v, color='red', pos=121)
+  draw.title(ref, "三维", pos=121)
+
+  foo = calc.xn2y([h, s], v, degree=3, output=True)
+  func = foo['func']
+
+  # change default color
+  draw.draw(DType.surface, h, s, Func=func,
+            ref=ref, pos=121, cmap='Pastel2_r',)
+  # auto-gen surface with dots, change default gird size
+  draw.draw(DType.wireframe, h, s, v,
+            ref=ref, pos=122, rstride=2, cstride=2)
+  draw.show()
+
+  # [Neo] and 3d solve equal
+  bar = calc.solveEq(foo['eq'], output=True)
+
+  if len(bar) > 0:
+    print('s> 750, 1.5 ~', bar[0]['func'](y=[750], x1=1.5))
+
+
+if __name__ == "__main__":
+  main()

nt25-0.1.2/src/nt25/scripts/test3d.py

@@ -0,0 +1,11 @@
+from nt25 import fio, draw, DType
+
+csv = fio.getCSV('ds/92.csv', width=11, startLine=1)
+if isinstance(csv, list):
+  P = csv[0]
+  Pa = csv[1]
+  R = csv[9]
+
+  ref = draw.draw(DType.dot3d, P, Pa, R)
+  draw.draw(DType.wireframe, P, Pa, R, ref=ref, color='orange')
+  draw.show()

nt25-0.1.0/src/nt25/lib/draw.py

@@ -1,141 +0,0 @@
-from enum import Enum
-from random import sample
-
-import numpy as np
-
-from matplotlib.axes import Axes
-from matplotlib import pyplot as plot
-
-# import matplotlib.animation as animation
-
-
-FONTS = ['PingFang SC', 'Microsoft YaHei', 'Arial']
-COLORS = ['blue', 'red', 'orange', 'black', 'pink']
-
-
-def _getPlot(ref, pos, font='Roboto') -> Axes:
-  if 'figure' not in ref:
-    ref['figure'] = plot.figure()
-    plot.rcParams['font.sans-serif'] = [font] + FONTS
-    # plot.rcParams['font.sans-serif'] = ['Arial']
-    plot.rcParams['axes.unicode_minus'] = False
-
-  if 'subplot' not in ref:
-    ref['subplot'] = {}
-
-  fig = ref['figure']
-  sub = ref['subplot']
-
-  if pos not in sub:
-    sub[pos] = fig.add_subplot(pos)
-
-  return sub[pos]
-
-
-def _genList(refer: list, length, random=False):
-  r = []
-
-  while len(r) < length:
-    r += sample(refer, len(refer)) if random else refer
-
-  return r[:length]
-
-
-def _coord(ref, X, Y, color, pos, randomColor, method, *args, **kwargs):
-  Xa = np.array(X)
-  Ya = np.array(Y)
-
-  if Xa.shape != Ya.shape:
-    print(f"bad shape {Xa.shape} != {Ya.shape}")
-    return
-
-  count = 1
-  # count = Xa.shape[0] if len(Xa.shape) > 1 else 1
-
-  if len(Xa.shape) > 1:
-    count = Xa.shape[0]
-    if count == 1:
-      X = X[0]
-      Y = Y[0]
-
-  if color is None:
-    color = _genList(COLORS, count, random=randomColor)
-
-  if count == 1:
-    if isinstance(color, (list, tuple)):
-      color = color[0]
-  elif len(color) != count:
-    print(f"bad color.len {len(color)} != {count}")
-    return
-
-  if pos is None:
-    pos = [111] * count
-
-  if count == 1:
-    if isinstance(pos, (list, tuple)):
-      pos = pos[0]
-  elif len(pos) != count:
-    print(f"bad pos.len {len(pos)} != {count}")
-    return
-
-  if count > 1 and isinstance(pos, list):
-    for i in range(count):
-      p = _getPlot(ref, pos[i])
-      method(p, X[i], Y[i], color=color[i], *args, **kwargs)
-  else:
-    p = _getPlot(ref, pos)
-    method(p, X, Y, color=color, *args, **kwargs)
-
-  return ref
-
-
-class DType(Enum):
-  scatter = 1,
-  line = 2,
-  func = 3,
-
-
-def d2d(type=DType.scatter, X=None, Y=None, Func=None, min=None, max=None,
-        ref=None, color=None, pos=None, randomColor=False, show=False,
-        *args, **kwargs):
-  if ref is None:
-    ref = {}
-
-  match type:
-    case DType.scatter:
-      func = Axes.scatter
-
-    case DType.line:
-      func = Axes.plot
-
-    case DType.func:
-      func = Axes.plot
-      if Func is not None and min is not None and max is not None:
-        if callable(Func):
-          Func = (Func,)
-
-        X = []
-        Y = []
-
-        for i in range(len(Func)):
-          dx = np.linspace(min[i] if isinstance(min, (list, tuple)) else min,
-                           max[i] if isinstance(max, (list, tuple)) else max)
-
-          X.append(dx)
-          Y.append([Func[i]([x]) for x in dx])
-
-  ref = _coord(ref, X, Y, color=color, pos=pos, randomColor=randomColor,
-               method=func, *args, **kwargs)
-
-  if show:
-    plot.show()
-
-  return ref
-
-
-def show():
-  plot.show()
-
-
-def clear():
-  plot.clf()

nt25-0.1.0/src/nt25/main.py

@@ -1,54 +0,0 @@
-from ntpy import fio, calc, draw, DType, __version__
-
-# import timeit
-# timeit.timeit('', number=100, globals=globals())
-
-
-def main():
-  print(f"Hello from {__package__}({__version__})! ")
-
-  # [Neo] some file I/O: csv, xlsx
-  fio.saveCSV({
-      'Name': ['Alice', 'Bob', 'Charlie'],
-      'Age': [25.2, 30, 35],
-      'City': ['New York', 'Los Angeles', 'Chicago']
-  }, "out.csv", colsInline=False)
-
-  data = fio.getXlsx('ds/qs.xlsx')
-  fio.saveCSV(data, "out2.csv")
-
-  h = data[0]
-  s = data[1]
-  v = data[2]
-
-  # [Neo] some poly calculates
-  c = calc.poly(h, v)
-  ce = calc.fl2el(c)
-  print(c, ce)
-
-  foo = calc.xn2y(h, v, degree=3, output=True)
-  bar = calc.solveEq(foo['eq'])
-
-  func = foo['func']
-  bfunc = bar[0]['func']
-
-  Y = range(1000, 2000, 200)
-  X = [bfunc(y) for y in Y]
-
-  # [Neo] draw 2d with types
-  ref = {}
-  draw.d2d(X=h, Y=v, ref=ref)
-  draw.d2d(type=DType.scatter, X=X, Y=Y, ref=ref, color='red', s=120)
-  draw.d2d(type=DType.func, Func=func, min=40, max=60, ref=ref, color='red')
-  draw.show()
-
-  # [Neo] and 3d calcs
-  foo = calc.xn2y([h, s], v, degree=3, output=False)
-  bar = calc.solveEq(foo['eq'], output=True)
-
-  if len(bar) > 0:
-    print('s> 750, 1.5 ~', bar[0]['func'](y=750, x1=1.5))
-
-
-if __name__ == "__main__":
-  main()